Much of the copious literature on the subject of sorting has concentrated on minimizing the number of comparisons and/or exchanges/copies. However, a more appropriate yardstick for the performance of sorting algorithms is based on the total number of array accesses that are required (the "work"). For a sort that is based on divide-and-conquer (including iterative variations on that theme), we can divide the work into linear, i.e. $\textbf{O}(N)$, work and linearithmic, i.e. $\textbf{O}(N log N)$, work. An algorithm that moves work from the linearithmic phase to the linear phase may be able to reduce the total number of array accesses and, indirectly, processing time. This paper describes an approach to sorting which reduces the number of expensive comparisons in the linearithmic phase as much as possible by substituting inexpensive comparisons. In Java, the two system sorts are dual-pivot quicksort (for primitives) and Timsort for objects. We demonstrate that a combination of these two algorithms can run significantly faster than either algorithm alone for the types of objects which are expensive to compare. We call this improved sorting algorithm Huskysort.