Product of set elements not exceeding a bound

a recursive implementation.

test[ list_, rem_ /; (Length@rem > 0), lim_] := Module[{next, r},
   next = Select[ {Append[list, #], Complement[rem, {#}]} & /@ rem , 
     (Times @@ #[[1]] <= lim) &];
   (Sow[#[[1]]]; test[#[[1]], #[[2]], lim]) & /@ next];
Union[Sort /@ Reap[test[{}, Range[10], 10]][[2, 1]]] 

{{1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {1, 2}, {1, 3}, {1, 4}, {1, 5}, {1, 6}, {1, 7}, {1, 8}, {1, 9}, {1, 10}, {2, 3}, {2, 4}, {2, 5}, {1, 2, 3}, {1, 2, 4}, {1, 2, 5}}

Select[Subsets[Range[10]], Times @@ # <= 10 &][[2 ;;]] == %

True

A bigger example, (This will break the Subsets approach )

 Union[Sort /@ Reap[test[{}, Range[100], 100]][[2, 1]]] // 
   Length // AbsoluteTiming 

{2.31678, 539}

Fun problem! Here is another recursive implementation. Note that I'm assuming that the input l is sorted and duplicate-free, like OP describes, i.e. Union[l] == l is True.

prods[l_, lim_] := 
 Block[{list = l, len = Length@l, storage = ConstantArray[0, Length@l]},
  Reap[
    Do[storage[[1]] = list[[i]];
     prodsRec[1, i, Quotient[lim, list[[i]]]]
     , {i, len}
     ]
    ][[2, 1]]
  ]

prodsRec[factorInd_, listPos_, lim_] := Block[{j = listPos + 1},
  Sow[storage[[1 ;; factorInd]]];
  While[j <= len && list[[j]] <= lim,
   storage[[factorInd + 1]] = list[[j]];
   prodsRec[factorInd + 1, j, Quotient[lim, list[[j]]]];
   j++
   ]
  ]

Looks more procedural than perhaps is usual around here, but should be pretty fast. Very little list manipulation means very little copying of lists due to Mathematica lists being immutable.

Testing one dense and one slightly sparse situation:

AbsoluteTiming[Length[prods[Range[100], 100]]]

{0.005645, 539}

rand = Union[RandomInteger[10000, 300]];
Length[rand]

299

AbsoluteTiming[Length[prods[rand, 10000]]]

{0.003750, 399}

An example closer to what OP describes in comments:

rand2 = Union@RandomInteger[10^8, 10^8*3/1000];
Length[rand2]

299 563

AbsoluteTiming[Length[bigExample = prods[rand2, 10^8]]]

{3.114989, 311 435}

Since the numbers in rand2 are sampled uniformly from Range[10^8], it's no surprise almost all products with two or more factors is waaaay larger than 10^8, so most "products" have only one factor:

Tally[Length /@ bigExample]

{{1, 299 563}, {2, 11 828}, {3, 44}}

It's much harder when the allowed factors are all "small":

AbsoluteTiming[Length[smallFactors = prods[Range[300], 10^5]]]

{14.771860, 1 470 607}

Tally[Length /@ smallFactors]

{{1, 300}, {2, 44 850}, {3, 344 016}, {4, 598 930}, {5, 384 643}, {6, 91 472}, {7, 6 345}, {8, 51}}