Japt, 5 3 bytes

ñg9

Test it online!

Explanation

I, too, have added a sorting function to my language in the last few weeks :-) ñ takes in an array and a function and sorts the array as if each item had been mapped through that function.

The g function on a string takes in a number n and returns the nth char in the string, wrapping if n is negative or past the end of the string. The strings can thus be aligned as follows:

quarterquarter...
dimedimedimedi...
nickelnickelni...
pennypennypenn...

The 9th char (0-indexed) of each string has been highlighted in bold. These are in the correct order, so all we have to do is ñg9. (Though now that I look back on it, ñg5 would work as well...)

V, 7 bytes

ú/¨qu©¿

Try it online!

This uses the spiffy new sort command I added to V around a week ago (ú). Sweet timing!

The way this works is by sorting every line by default sorting (ASCII values) but ignoring the first match of a certain regex. In this case, the regex is (qu)?, although it has some gross non-ASCII stuff to avoid using backslashes. If you ignore the first two letters of "quarter", it starts with 'a', and then all of the coins are already in alphabetical order.

Non-competing version, 4 bytes

ú!/.

This feature was already implemented, but I hadn't tested it extensively yet so it had a bug that I only realized because of this challenge. There is no TIO link because TIO is slightly behind.

This works by reverse sorting every line but ignoring the first character on each line.

Python, 36 bytes

lambda a:a.sort(key=lambda x:x[-5:])

Unnamed function that sorts the list in-place by the key function given.

The slices of each coin name are then, arter, dime, ickel, and penny - which are in alphabetical (or more importantly, ordinal) order.

Python 3, 42 41 38 bytes

An unnamed lambda function which takes input as a list of strings, sorts in place.

(Outgolfed by Jonathan Allan)

lambda x:x.sort(key=lambda s:(s*2)[5])

Try it online!

Other solutions I messed around with:

lambda x:x.sort(key=lambda s:s*(s<'q'))
lambda x:x.sort(key=lambda s:(s+'pi')[5])
lambda x:x.sort(key=lambda s:ord(s[3])%16)

Jelly, 4 bytes

6ịµÞ

Try it online! (the footer, ÇY, joins the resulting list with line feeds for a prettier print out.)

How?

6ịµÞ - Main link: list of strings
  µ  - monadic chain separation
   Þ - sort the list of strings by the monadic function:
6ị   - the sixth index - Jelly indexing is modular and 1-based

The Nth index of a list in Jelly is the Nth item starting at the left, counting from 1, and looping back to the start when need be. (The 0th is at the right, the -1th one left of that and so on too).

So the sixth character of ['d','i','m','e'] is 'i' since six is congruent to two modulo four.

The sixth character of the four coins in order are quarter, dime, nickel, penny . These are in alphabetical (or more importantly, ordinal) order.

Another way to achieve the same thing would be to sort by the rotated strings with ṙ5µÞ, where ṙ rotates to the right, making the strings erquart, imed, lnicke, and penny.

Pyke, 9 7 5 bytes

.#5R@

Try it here!

.#5R@ - sort_by:
  5R@ -  i[5]

CJam, 8 bytes

q~{5=}$p

Try it online!

Explanation

q~        Get and eval all input (array of coin names)
  {5=}$   Sort the array by the 5th index of each element (array indices loop in CJam)
       p  Print the result

Bash (+coreutils) 11 bytes

Golfed

sort -rk1.2

Test

>echo penny nickel dime quarter|tr ' ' '\n'|sort -rk1.2

quarter
dime
nickel
penny

Try It Online !

Retina, 10

• 6 10 bytes saved thanks to @ETHproductions

q
b
O`
b
q

• Substitute q to b
• Sort
• Substitute b back to q

Try it online.

Python, 32 bytes

lambda s:s.sort(key="npr".strip)

Try it online! Sorts the list in place.

The idea is to use a sorting key function without a lambda. A good candidate was x.strip, which takes the string x and removes its the left and right edges all characters in the input. For example, "abcdef".strip("faces") == "bcd".

The method "npr".strip takes:

quarter ->  np
dime    ->  npr
nickel  ->  pr
penny   ->  r

which are lexicographically sorted. I found the string npr by brute force. npu and npt also work, and there are none shorter.

V, 8 7 bytes

1 byte saved thanks to @DJMcMayhem

Úçq/:m0

[Try it online!]

See @DJMcMayhem's answer in V (1 0 bytes shorter than mine)

Try it online!

Ú                    " sort all lines "
 ç                   " globally "
  q/                 "  where there a q is matched, "
    :m0              "  move it to the top of the buffer "

Here is an older solution at 1 byte larger, but I really like it.

V, 8 bytes

Ú/q
dGHP

[Try it online!]

Try it online!

Explanation

Ú        " sorts the lines

Now the buffer will be in this format:

dimes
nickels
pennies
quarters

The only thing left to do now is to move the quarters to the top.

/q      " search for a q "
dG      " delete everything from the first quarter to the end of buffer "
HP      " and paste it at the top of the buffer

PowerShell, 21 bytes

$args|sort{($_*3)[9]}

Try it online!

Explanation

Shamelessly stole the algorithm in ETHproductions's answer (basically). I multiply each string by 3, then sort based on the 9th character of the resulting string.

Bash + coreutils, 18

tr q b|sort|tr b q

• Transliterate q to b
• Sort
• Transliterate b back to q

Try it online.

JavaScript (ES6), 35 33 bytes

a=>a.sort(([,...a],[,...b])=>b>a)

Test cases

let f =

a=>a.sort(([,...a],[,...b])=>b>a)

console.log(f(['penny','nickel','dime','quarter']).join` `);
console.log(f(['nickel','penny','penny','quarter','quarter','quarter','dime','dime','dime','dime']).join` `);
console.log(f(['quarter','dime','nickel','nickel','quarter','dime','penny','penny']).join` `);

Japt, 3 bytes

ñé5

Try it online!

Batch, 82 bytes

@for %%c in (quarter dime nickel penny)do @for %%a in (%*)do @if %%a==%%c echo %%c

Takes input as command-line arguments and outputs to STDOUT. Works by concatenating the lists resulting from filtering the original list on each coin.

T-SQL, 41 36 34 bytes

select*from @ order by right(a,5)

Explanation

Assume the input is pre-loaded in a table variable named @, with a single column named a, where each value is one coin to be sorted.

The select * from @ part is boiler-plate 'get all values to return'. The real magic happens in the order by clause.

Using the same strategy as Johnathan Allan, I sort by the last five characters (SQL will return the entire string if it's too short): arter, dime, ickel, penny.

Ruby, 34 bytes

->m{m.sort_by{|c|c[1..2]}.reverse}

input and output as an array of strings