Jelly, 7 4 bytes

æḟÆR

Try it online!

How it works

æḟÆR  Main link. Argument: n

  ÆR  Prime range; yield all primes in [1, ..., n].
æḟ    Power floor; round n down to the nearest power of each prime in the range.

Mathematica, 44 43 40 bytes

Saved 4 bytes thanks to miles and Martin Ender

n#^⌊#~Log~n⌋&/@Select[Range@n,PrimeQ]

(x=Prime@Range@PrimePi@#)^⌊x~Log~#⌋&

⌊ and ⌋ are the 3 byte characters U+230A and U+230B representing \[LeftFloor] and \[RightFloor], respectively.

Explanation:

Pure function. # is short for Slot[1] which represents the first argument to the Function. PrimePi@# counts the number of primes less or equal to #, Range@PrimePi@# is the list of the first PrimePi[#] positive integers, and so Prime@Range@PrimePi@# is the list of primes less than or equal to # (this is one byte shorter than Select[Range@#,PrimeQ]). The symbol x is Set equal to this list, then raised to the Power ⌊x~Log~#⌋, which is the list of Floor[Log[n,#]] for each n in x. In Mathematica, raising a list to the Power of another list of the same length results in the list of the powers of their corresponding elements.

MATL, 13 bytes

ZqG:!^tG>~*X>

Try it Online!

Explanation

        % Implicitly grab the input as a number (N)
Zq      % Get an array of all primes below N
G:!     % Create an array from [1...N]
^       % Raise each prime to each power in this array which creates a 2D matrix
        % where the powers of each prime are down the columns
tG>~    % Create a logical matrix that is TRUE where the values are less than N
*       % Perform element-wise multiplication to force values > N to zero
X>      % Compute the maximum value of each column
        % Implicitly display the resulting array

Pyth, 13 bytes

m^ds.lQdfP_TS

Try it here!

        f   S -  filter(v, range(1, input))
         P_T  -   is_prime(T)
m             - map(v, ^)
    .lQd      -    log(input, d)
   s          -   int(^)
 ^d           -  d ** ^

I haven't played with Pyth in a while so any golfing tips are appreciated.

Jelly, 12 9 bytes

RÆEz0iṀ$€

Try it online! (method is too slow for the 10000 case).

How?

Builds the list of p^k in order of p.

RÆEz0iṀ$€ - Main link: n                      e.g. 7
R         - range(n)                          [1 ,2  ,3    ,4  ,5      ,6    ,7]
 ÆE       - prime factor vector (vectorises)  [[],[1],[0,1],[2],[0,0,1],[1,1],[0,0,0,1]]
   z0     - transpose with filler 0           [[0,1,0,2,0,1,0],[0,0,1,0,0,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,1]]
       $€ - la$t two links as a monad, for €ach       ^             ^                   ^                   ^
     i    -     first index of                        4             3                   5                   7
      Ṁ   -     maximum                       [4,3,5,7]

Jelly, 8 bytes

ÆR*ÆE€»/

Try it online!

How it works

ÆR*ÆE€»/  Main link. Argument: n

ÆR        Prime range; yield all primes in [1, ..., n].
   ÆE€    Prime exponents each; yield the exponents of 2, 3, 5, ... of the prime
          factorization of each k in [1, ..., n].
          For example, 28 = 2² × 3⁰ × 5⁰ × 7¹ yields [2, 0, 0, 1].
  *       Exponentiation; raise the elements of the prime range to the powers
          of each of the exponents arrays.
      »/  Reduce the columns by maximum.

CJam, 21 20 bytes

Saved 1 byte thanks to Martin Ender

ri_){mp},f{\1$mLi#}p

Try it online!

Explanation

ri                    e# Read an integer from input (let's call it n)
  _                   e# Duplicate it
   ){mp},             e# Push the array of all prime numbers up to and including n
         f{           e# Map the following block to each prime p:
           \          e#   Swap the top two elements of the stack
            1$        e#   Copy the second element down in the stack. Stack is now [p n p]
              mL      e#   Take the base-p logatithm of n
                i     e#   Cast to int (floor)
                 #    e#   Raise p to that power
                  }   e# (end of map block)
                   p  e# Print

I couldn't get a shorter Mathematica solution than ngenisis's solution, but I thought I'd offer a couple of (hopefully interesting) alternative approaches.

Mathematica, 65 bytes

#/#2&@@@({#,#}&/@Range@#~Select~PrimeQ//.{a_,b_}/;a<=#:>{b a,b})&

First we use {#,#}&/@Range@#~Select~PrimeQ to build a list of all primes in the appropriate range, but with ordered pairs of each prime, like { {2,2}, {3,3}, ...}. Then we operate on that list repeatedly with the replacement rule {a_,b_}/;a<=#:>{b a,b}, which multiplies the first element of the ordered pair by the second until the first element exceeds the input. Then we apply #/#2&@@@ to output, for each ordered pair, the first element divided by the second. (They end up sorted by the underlying prime: an example output is {16, 9, 5, 7, 11, 13, 17, 19}.)

Mathematica, 44 bytes

Values@Rest@<|MangoldtLambda@#->#&~Array~#|>&

The von Mangoldt function Λ(n) is an interesting number theory function: it equals 0 unless n is a prime power p^k, in which case it equals log p (not log n). (These are natural logs, but it won't matter.) Thus MangoldtLambda@#->#&~Array~# creates an array of rules { 0->1, Log[2]->2, Log[3]->3, Log[2]->4, Log[5]->5, 0->6, ... } whose length is the input integer.

We then turn this list of rules into an "association" using <|...|>. This has the effect of retaining only the last rule with any given left-hand value. In other words, it will throw away Log[2]->2 and Log[2]->4 and Log[2]->8 and keep only Log[2]->16 (assuming that the input is between 16 and 31 for this example). Therefore the only remaining right-hand sides are the maximal prime powers—except for the one remaining rule 0->n, where n is the largest non-prime-power up to the input integer. But Rest throws that undesired rule away, and Values extracts the right-hand sides from the rules in the association. (They end up sorted as above.)

05AB1E, 15 12 bytes

ƒNpiN¹N.nïm,

Try it online!

Explanation

ƒ             # for N in [0 ... input]
 Npi          # if N is prime
    N         # push N
     ¹N.n     # push log_N(input)
         ï    # convert to int
          m   # raise N to this power
           ,  # print

Jelly, 9 bytes

Ræl/ÆF*/€

One byte longer than my other answer, but finishes for input 10,000 is a couple of seconds.

Try it online!

How it works

Ræl/ÆF*/€  Main link. Argument: n

R          Range; yield [1, ..., n].
 æl/       Reduce by least common multiple.
    ÆF     Factor the LCM into [prime, exponent] pairs.
      */€  Reduce each pair by exponentiation.

Sage, 39 bytes

lambda i:prime_powers(i)[-prime_pi(i):]

Just discovered the prime_pi function that counts the number of primes. Gotta thank the autocomplete feature!

Old attempt, 43 bytes

lambda i:[x^int(ln(i,x))for x in primes(i)]

Maps each prime in the range primes(i) to its maximal prime power. ln is just an alias of log so it accepts alternate bases although its name suggests it can only use base e.

JavaScript (ES6), 118 120 119 114 112 105 bytes

(n,r)=>(r=k=>[...Array(k-1)].map((_,i)=>i+2),r(n).filter(q=>r(q).every(d=>q%d|!(d%(q/d)*(q/d)%d)&q*d>n)))

Suggestions welcome. This is kind of long, but it seemed worth posting because it does all the divisibility testing explicitly rather than using built-ins related to primes.

Notes:

• A natural number q is a prime power <=> all of q's divisors are powers of the same prime <=> for any d which divides q, one of d and q/d is a divisor of the other.
• If q is a power of p, q is maximal <=> q * p > n <=> q * d > n for every nontrivial divisor d of q.