diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/ResultTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/ResultTests.java
index bb64a365b3..de21ce97ee 100644
--- a/jOOQ-test/src/org/jooq/test/_/testcases/ResultTests.java
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/ResultTests.java
@@ -79,7 +79,13 @@ extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, I, IPK, T658,
     public void testResultSort() throws Exception {
         Result<B> result = create().fetch(TBook());
 
-        class C implements Comparator<Integer> {
+        assertTrue(result == result.sortAsc(TBook_ID()));
+        assertEquals(asList(1, 2, 3, 4), result.getValues(TBook_ID()));
+
+        assertTrue(result == result.sortDesc(TBook_ID()));
+        assertEquals(asList(4, 3, 2, 1), result.getValues(TBook_ID()));
+
+        class C1 implements Comparator<Integer> {
 
             @Override
             public int compare(Integer o1, Integer o2) {
@@ -92,16 +98,26 @@ extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, I, IPK, T658,
             }
         }
 
-        assertTrue(result == result.sortAsc(TBook_ID()));
-        assertEquals(asList(1, 2, 3, 4), result.getValues(TBook_ID()));
-
-        assertTrue(result == result.sortDesc(TBook_ID()));
-        assertEquals(asList(4, 3, 2, 1), result.getValues(TBook_ID()));
-
-        assertTrue(result == result.sortAsc(TBook_ID(), new C()));
+        assertTrue(result == result.sortAsc(TBook_ID(), new C1()));
         assertEquals(asList(2, 3, 4, 1), result.getValues(TBook_ID()));
 
-        assertTrue(result == result.sortDesc(TBook_ID(), new C()));
+        assertTrue(result == result.sortDesc(TBook_ID(), new C1()));
+        assertEquals(asList(1, 4, 3, 2), result.getValues(TBook_ID()));
+
+        class C2 implements Comparator<B> {
+
+            private final C1 c1 = new C1();
+
+            @Override
+            public int compare(B book1, B book2) {
+                return c1.compare(book1.getValue(TBook_ID()), book2.getValue(TBook_ID()));
+            }
+        }
+
+        assertTrue(result == result.sortAsc(new C2()));
+        assertEquals(asList(2, 3, 4, 1), result.getValues(TBook_ID()));
+
+        assertTrue(result == result.sortDesc(new C2()));
         assertEquals(asList(1, 4, 3, 2), result.getValues(TBook_ID()));
     }
 }
diff --git a/jOOQ/src/main/java/org/jooq/Result.java b/jOOQ/src/main/java/org/jooq/Result.java
index 3458f41786..1af2f796be 100644
--- a/jOOQ/src/main/java/org/jooq/Result.java
+++ b/jOOQ/src/main/java/org/jooq/Result.java
@@ -1918,4 +1918,20 @@ public interface Result<R extends Record> extends FieldProvider, List<R>, Attach
      * @return The result itself
      */
     <T> Result<R> sortDesc(Field<T> field, java.util.Comparator<? super T> comparator);
+
+    /**
+     * Sort this result using a comparator that can compare records.
+     *
+     * @param comparator The comparator used to sort this result.
+     * @return The result itself
+     */
+    Result<R> sortAsc(java.util.Comparator<? super R> comparator);
+
+    /**
+     * Reverse-sort this result using a comparator that can compare records.
+     *
+     * @param comparator The comparator used to sort this result.
+     * @return The result itself
+     */
+    Result<R> sortDesc(java.util.Comparator<? super R> comparator);
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java b/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
index b8ae613615..433c55c2e2 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
@@ -1330,7 +1330,12 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
 
     @Override
     public final <T> Result<R> sortAsc(Field<T> field, Comparator<? super T> comparator) {
-        Collections.sort(this, new RecordComparator<T>(getIndex(field), comparator));
+        return sortAsc(new RecordComparator<T, R>(getIndex(field), comparator));
+    }
+
+    @Override
+    public final Result<R> sortAsc(Comparator<? super R> comparator) {
+        Collections.sort(this, comparator);
         return this;
     }
 
@@ -1344,10 +1349,15 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
         return sortAsc(field, Collections.reverseOrder(comparator));
     }
 
+    @Override
+    public final Result<R> sortDesc(Comparator<? super R> comparator) {
+        return sortAsc(Collections.reverseOrder(comparator));
+    }
+
     /**
      * A comparator for records, wrapping another comparator for &lt;T&gt;
      */
-    private class RecordComparator<T> implements Comparator<R> {
+    private static class RecordComparator<T, R extends Record> implements Comparator<R> {
 
         private final Comparator<? super T> comparator;
         private final int fieldIndex;
@@ -1367,7 +1377,7 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
     /**
      * A natural comparator
      */
-    private class NaturalComparator<T extends Comparable<? super T>> implements Comparator<T> {
+    private static class NaturalComparator<T extends Comparable<? super T>> implements Comparator<T> {
 
         @Override
         public int compare(T o1, T o2) {