##JavaScript (ES6), <s>119</s> <s>118</s> 117 bytes

A recursive function that takes a 0-based index.

<!-- language: lang-js -->

    f=(n,a=[2,m=3])=>a[n]||a.map(c=>a.map(d=>c<d&(d*=c)>m?b[d]=b[d]/0||d:0),b=[])|f(n,a.push(m=b.sort((a,b)=>a-b)[0])&&a)

###How?

At each iteration of ***f()***, we use the last term ***m*** of the sequence and an initially empty array ***b*** to identify the next term. For each product ***d > m*** of two earlier distinct MU-numbers, we do:

<!-- language: lang-js -->

    b[d] = b[d] / 0 || d

and then keep the minimum value of ***b***.

The above expression is evaluated as follows:

    b[d]               | b[d] / 0  | b[d] / 0 || d
    -------------------+-----------+--------------
    undefined          | NaN       | d
    already equal to d | +Infinity | +Infinity
    +Infinity          | +Infinity | +Infinity

This guarantees that products which can be expressed in more than one way will never be selected.

###Formatted and commented

<!-- language: lang-js -->

    f = (n, a = [2, m = 3]) =>           // given: n = input, a[] = MU array, m = last term
      a[n] ||                            // if a[n] is defined, return it
      a.map(c =>                         // else for each value c in a[]:
        a.map(d =>                       //   and for each value d in a[]:
          c < d &                        //     if c is less than d and
          (d *= c) > m ?                 //     d = d * c is greater than m:
            b[d] = b[d] / 0 || d         //       b[d] = either d or +Infinity (see 'How?')
          :                              //     else:
            0                            //       do nothing
        ),                               //   end of inner map()
        b = []                           //   initialization of b[]
      ) |                                // end of outer map()
      f(                                 // do a recursive call:
        n,                               //   - with n
        a.push(                          //   - push in a[]:
          m = b.sort((a, b) => a - b)[0] //     m = minimum value of b[]
        ) && a                           //     and use a[] as the 2nd parameter
      )                                  // end of recursive call
###Demo

<!-- begin snippet: js hide: true console: true babel: false -->

<!-- language: lang-js -->

    f=(n,a=[2,m=3])=>a[n]||a.map(c=>a.map(d=>c<d&(d*=c)>m?b[d]=b[d]/0||d:0),b=[])|f(n,a.push(m=b.sort((a,b)=>a-b)[0])&&a)

    for(var n = 0; n < 10; n++) {
      console.log('MU[' + n + '] = ' + f(n));
    }

<!-- end snippet -->