Linear Peano multiplication in Scheme?
Let's look at a simpler problem first: counting the length of a list. Here's the recursive way to do it:

(define (length lst)
  (if (null? lst)
      0
      (+ 1 (length (cdr lst)))))


Okay, so, what would it look like if instead of recursing, we kept a running count of the length instead?

(define (length lst)
  (length-aux lst 0))

(define (length-aux lst count)
  (if (null? lst)
      count
      (length-aux (cdr lst) (+ 1 count))))


Here, length-aux tail-recurses into itself over and over with a new running count until we hit the end of the list, at which point we return the count.

This idiom is common enough that Scheme has a concept called named let, which you can use like this:

(define (length lst)
  (let loop ((lst lst)
             (count 0))
    (if (null? lst)
        count
        (loop (cdr lst) (+ 1 count)))))


You can use a similar approach for solving your problem iteratively:

(define (mX n m)
  (let loop ((m m)
             (product 0))
    (if (zero? m)
        product
        (loop (- m 1) (+ product n)))))


Notice that we are not setting variables here. We are doing a tail recursion into loop, which is passed the new m and product values as arguments.