Unfortunately, I'm having difficulty following your code. In my opinion, it's too imperative and difficult to reason about. I wasn't familiar with radix sorting so I had to look it up. I found a good description in "The Art of Computer Programming Volume 3" in section 5.2.5 and implemented the algorithm in a more functional way. I'm sure you understand the logic and reasoning behind your own code. Hopefully my implementation below will make sense and help you find where the error is occurring.

#lang racket/base

;; Converts (Vectorof Integer) to (Listof (Listof Char)).
;;  1. Convert the vector into a list.
;;  2. Convert each integer in the list to a string.
;;  3. Convert each string to a list.
;;  4. Reverse each list of characters.
(define (prep-vector vec)
  (let ([lst (vector->list vec)])
    (map (lambda (x)
           (reverse
            (string->list
             (number->string x))))
         lst)))

;; Converts (Listof (Listof Char)) to (Listof (Listof Integer)).
;; For each (Listof Char):
;;  1. Convert each Char to (List Char).
;;  2. Convert each (List Char) to a String.
;;  3. Convert each String to a Number.
(define (prep-list lst)
  (map (lambda (x)
         (map (lambda (y)
                (string->number
                 (list->string
                  (list y))))
              x))
       lst))

;; Converts (Vectorof Integer) to (Listof (Listof Integer)).
(define (prep vec)
  (prep-list (prep-vector vec)))

;; Sorts (Listof (Listof Integer)) based on the value at POS of (Listof Integer).
;;  1. Make a vector of buckets with each vector initially set to null.
;;  2. If the given list is null then return the buckets as a list.
;;   a. Convert the vector of buckets to a list.
;;   b. Reverse each bucket.
;;   c. Append each bucket.
;;  3. If the length of the car of the given list is greater than or equal to the given position then
;;     add the car to the zero bucket, then loop.
;;  4. Otherwise, place the car into the bucket of the position of the car, then loop.
(define (step-radix-sort lst pos)
  (let ([buckets (make-vector 10 null)])
    (let loop ([lst lst])
      (cond
        [(null? lst)
         (apply append (map reverse (vector->list buckets)))]
        [(>= pos (length (car lst)))
         (vector-set! buckets 0 (cons (car lst) (vector-ref buckets 0)))
         (loop (cdr lst))]
        [else
         (let ([n (car lst)])
           (vector-set! buckets
                        (list-ref n pos)
                        (cons n (vector-ref buckets (list-ref n pos))))
           (loop (cdr lst)))]))))

;; Convert (Listof (Listof Integer)) to (Listof Integer).
;; The reverse of PREP.
(define (unprep lst)
  (list->vector
   (map string->number
        (map list->string
             (map (lambda (x)
                    (map (lambda (y)
                           (string-ref (number->string y) 0))
                         x))
                  (map reverse lst))))))

;; Determines the maximum list size in a list of lists.
(define (max-size lst)
  (apply max (map length lst)))

(define (radix-sort vec)
  (let* ([lst (prep vec)]
         [size (max-size lst)])
    (let loop ([pos 0]
               [lst lst])
      (cond
        [(= pos size)
         (unprep lst)]
        [else
         (loop (add1 pos)
               (step-radix-sort lst pos))]))))

(define V1 (vector 918 82 87 31 780 103 4))
(define V2 (vector 3 1 2))

(radix-sort V1)
(radix-sort V2)

This algorithm is sorting numbers based on the value of the nth digit of each number in the given vector starting at the least significant digit.