I did something cleverer to only visit the elements of the list once each time I needed to partition with my prolog sort:
qsort(List, Sorted):- qsort(List, [], Sorted),
qsort([], Sorted, Sorted).
qsort([H|Tail], OtherList, Sorted) :-
  partition(H, Tail, L, G),
  qsort(G, OtherList, Gs),
  qsort(L, [H|Gs], Sorted).

The first one is a helper that takes two arguments, and sorts the first one into the second one using qsort/3.
The next line is a rough equivalent of saying that an empty list is sorted: the next argument is effectively an accumulator.
The final clause takes a non-empty list, and an already sorted accumulator, and sorts them. It partitions, and the recursively sorts the two halves.

(There’s also a naive version that appends sorted lists rather than using an accumulator, but that is not nearly as clever.)

The partition function is a little tricky:
partition(_, [], [], []).
partition(X, [X|List], L, G) :- partition(X, List, L, G).
partition(X, [E|List], [E|L], G) :- E < X, partition(X, List, L, G).
partition(X, [E|List], L, [E|G]) :- E > X, partition(X, List, L, G).

This states that an empty list partitions into two empty lists.
The second clause states that we strip out any duplicates of the pivot.
The final two clauses actually partition the list.

Granted, this isn’t quite as nice as the Haskell version, but for me, having this (and the Scheme solution detailed above) really switched me onto FP. We had previously coded quicksort and mergesort in Java (and I had then done the same in C, and Python, just for good measure), and the pure beauty of the code here compared to the vulgar mess of Java made me a fan.