Insert statement converted from SML to racket not functioning

I have learned SML pretty in depth and have learned about the similarities between racket and SML, I'm now trying to convert some of my past sml projects to racket, this one involves binary trees.

In SML the following binary tree and function I'm attempting to convert to Racket are as follows:

datatype 'a bin_tree = 
    Leaf of 'a
  | Node of 'a bin_tree    (* left tree *)
           * int           (* size of left tree *)
           * int           (* size of right tree *)
           * 'a bin_tree   (* right tree *)

val tree1 =
  Node(Node(Node(Leaf 47, 1, 1, Leaf 38),
            2,1,
            Leaf 55),
       3,2,
       Node(Leaf 27, 1, 1, Leaf 96))

val tree1false =
  Node(Node(Node(Leaf 47, 1, 1, Leaf 38),
            2,1,
            Leaf 55),
       4,2,
       Node(Leaf 27, 1, 1, Leaf 96))

val tree2 =
  Node(Node(Leaf 55,
            1,2,
            Node(Leaf 47, 1, 1, Leaf 38)),
       3,2,
       Node(Leaf 27, 1, 1, Leaf 96))

val tree3 =
  Node(Node(Node(Leaf 47, 1, 1, Leaf 38),
            2,2,
            Node(Leaf 55, 1, 1, Leaf 54)),
       4,2,
       Node(Leaf 27, 1, 1, Leaf 96))
       
fun insert newValue (Leaf n) = Node(Leaf newValue, 1, 1, Leaf n)
  | insert newValue (Node(left, l, r, right)) =
      if (l <= r)
        then (Node(insert newValue left, l + 1, r, right))
      else
        (Node(left, l, r + 1, insert newValue right));

In SML all the above is functioning, in racket everything is functioning except the insert, please help:

#lang racket

(provide Leaf)
(provide Node)

(provide size)
(provide verify)
(provide imbalances)
(provide insert)

(provide test1)
(provide test1false)
(provide test2)
(provide test3)

(struct Leaf (content))
(struct Node (left lsize rsize right))

(define test1
  (Node (Node (Node (Leaf 47) 1 1 (Leaf 38))
              2 1
              (Leaf 55))
         3 2
         (Node (Leaf 27) 1 1 (Leaf 96))))

(define test1false
  (Node (Node (Node (Leaf 47) 1 1 (Leaf 38))
              2 1
              (Leaf 55))
         4 2
         (Node (Leaf 27) 1 1 (Leaf 96))))

(define test2
  (Node (Node (Leaf 55)
              1 2
              (Node (Leaf 47) 1 1 (Leaf 38)))
        3 2
        (Node (Leaf 27) 1 1 (Leaf 96))))

(define test3 
  (Node (Node (Node (Leaf 47) 1 1 (Leaf 38))
               2 2
              (Node (Leaf 55) 1 1 (Leaf 54)))
         4 2
        (Node (Leaf 27) 1 1 (Leaf 96))))

(define (insert x tree)
    (cond
        [(Leaf? tree) 0]
        [(Node? tree) (<= (Node-lsize tree) (Node-rsize tree)) (Node ((insert x (Node-left tree)) (+ (Node-lsize tree) 1) (Node-rsize tree) (Node-right tree)))]
        [else (Node ((Node-left tree)  (Node-lsize tree) (+ (Node-rsize tree) 1) ((insert x (Node-right tree)))))]

    ))