@@ -1275,6 +1275,17 @@ Elasticsearch and Solr do: a query which streamed 500,000 ids from Elasticsearch
 after every change, so that a hundred index queries of one result each in a transaction take 0.71 ms instead of 0.89 on
 one thread, and 1.1 ms instead of 3.1 with eight threads running such transactions at once, on the inmemory backend.
 
+##### Graph queries which JanusGraph sorts leave out the vertices which the transaction removed
+
+A graph query ordered by a key which its index doesn't sort it by, such as one which a composite index answers, or a
+mixed index which doesn't hold the order key, failed in a transaction which had removed one of the vertices it matched,
+with an `IllegalStateException` that the vertex was removed: JanusGraph sorted what the index returned before it left
+out the elements which the transaction had removed, and read the order key of the removed vertex. It now leaves out the
+removed vertices before it sorts the others, as the query without an order leaves them out. So
+`g.V().has('kind', 'p').order().by('name')`, with `kind` in a composite index, returns the vertices of kind `p` which
+are left in a transaction which dropped one of them, as does
+`graph.query().has('kind', 'p').orderBy('name', asc).vertices()`.
+
 ##### Graph queries read on past the edges and properties which the transaction removed
 
 An index, mixed or composite, still holds the edges and vertex properties which the transaction removed, until it
 
@@ -5401,6 +5401,46 @@ public void testLimitedQueriesOfPropertiesReadPastThePropertiesWhichTheTransacti
         }
     }
 
+    /**
+     * An ordered query which a mixed index answers without sorting it, as the index doesn't hold the order key, leaves
+     * out the vertices which the transaction removed, which the index still returns, before JanusGraph sorts them, as
+     * the order values of a removed vertex can't be read; the edges which it removed, whose ids turn into no element,
+     * are left out as well
+     */
+    @Test
+    public void testQueriesSortedInMemorySkipTheElementsWhichTheTransactionRemoved() {
+        final PropertyKey kind = makeKey("kind", String.class);
+        makeKey("name", String.class);
+        mgmt.makeEdgeLabel("road").multiplicity(Multiplicity.MULTI).make();
+        mgmt.buildIndex("mixed", Vertex.class).addKey(kind, getStringMapping()).buildMixedIndex(INDEX);
+        mgmt.buildIndex("edges", Edge.class).addKey(kind, getStringMapping()).buildMixedIndex(INDEX);
+        finishSchema();
+        final Vertex from = tx.addVertex("kind", "q");
+        for (final String name : Arrays.asList("a", "b", "c", "d")) {
+            from.addEdge("road", tx.addVertex("kind", "p", "name", name), "kind", "p", "name", name);
+        }
+        newTx();
+        final GraphTraversalSource g = tx.traversal();
+        //The vertex named b, and with it its edge, and the edge named c
+        g.V().has("kind", "p").has("name", "b").drop().iterate();
+        g.E().has("kind", "p").has("name", "c").drop().iterate();
+        assertEquals(Arrays.asList("a", "c", "d"), g.V().has("kind", "p").order().by("name").values("name").toList());
+        assertEquals(Arrays.asList("d", "c"),
+            g.V().has("kind", "p").order().by("name", desc).limit(2).values("name").toList());
+        final List<Object> vertexNames = new ArrayList<>();
+        tx.query().has("kind", "p").orderBy("name", asc).vertices().forEach(v -> vertexNames.add(v.value("name")));
+        assertEquals(Arrays.asList("a", "c", "d"), vertexNames);
+        assertEquals(Arrays.asList("a", "d"), g.E().has("kind", "p").order().by("name").values("name").toList());
+        assertEquals(Collections.singletonList("d"),
+            g.E().has("kind", "p").order().by("name", desc).limit(1).values("name").toList());
+        final List<Object> edgeNames = new ArrayList<>();
+        tx.query().has("kind", "p").orderBy("name", asc).edges().forEach(e -> edgeNames.add(e.value("name")));
+        assertEquals(Arrays.asList("a", "d"), edgeNames);
+        assertEquals(Arrays.asList("a", "d"),
+            g.V(from).local(__.outE("road").order().by("name")).values("name").toList());
+        tx.rollback();
+    }
+
     //A query which removes the edges it reads, as it reads them, gets each of its edges once: a read under a larger
     //limit skips what the index returned before, rather than as many edges as were returned, which are removed by then
     @Test
 
@@ -476,6 +476,102 @@ public void testUpdateEdgePropertyThenRemoveEdge() {
         assertTrue(graph.traversal().E().has("_e", 2).hasNext());
     }
 
+    /**
+     * An ordered query which JanusGraph sorts itself, as its index doesn't sort it, leaves out the vertices which the
+     * transaction removed before it sorts them, as the order values of a removed vertex can't be read; the edges which
+     * it removed, whose ids turn into no element, are left out as well
+     */
+    @Test
+    public void testQueriesSortedInMemorySkipTheElementsWhichTheTransactionRemoved() {
+        final PropertyKey kind = makeKey("kind", String.class);
+        makeKey("name", String.class);
+        mgmt.makeEdgeLabel("road").multiplicity(Multiplicity.MULTI).make();
+        mgmt.buildIndex("verticesByKind", Vertex.class).addKey(kind).buildCompositeIndex();
+        mgmt.buildIndex("edgesByKind", Edge.class).addKey(kind).buildCompositeIndex();
+        finishSchema();
+        final Vertex from = tx.addVertex("kind", "q");
+        for (final String name : Arrays.asList("a", "b", "c", "d")) {
+            from.addEdge("road", tx.addVertex("kind", "p", "name", name), "kind", "p", "name", name);
+        }
+        newTx();
+        final GraphTraversalSource g = tx.traversal();
+        //The vertex named b, and with it its edge, and the edge named c
+        g.V().has("kind", "p").has("name", "b").drop().iterate();
+        g.E().has("kind", "p").has("name", "c").drop().iterate();
+        assertEquals(Arrays.asList("a", "c", "d"), g.V().has("kind", "p").order().by("name").values("name").toList());
+        assertEquals(Arrays.asList("d", "c"),
+            g.V().has("kind", "p").order().by("name", desc).limit(2).values("name").toList());
+        final List<Object> vertexNames = new ArrayList<>();
+        tx.query().has("kind", "p").orderBy("name", asc).vertices().forEach(v -> vertexNames.add(v.value("name")));
+        assertEquals(Arrays.asList("a", "c", "d"), vertexNames);
+        assertEquals(Arrays.asList("a", "d"), g.E().has("kind", "p").order().by("name").values("name").toList());
+        assertEquals(Collections.singletonList("d"),
+            g.E().has("kind", "p").order().by("name", desc).limit(1).values("name").toList());
+        final List<Object> edgeNames = new ArrayList<>();
+        tx.query().has("kind", "p").orderBy("name", asc).edges().forEach(e -> edgeNames.add(e.value("name")));
+        assertEquals(Arrays.asList("a", "d"), edgeNames);
+        assertEquals(Arrays.asList("a", "d"),
+            g.V(from).local(__.outE("road").order().by("name")).values("name").toList());
+        tx.rollback();
+    }
+
+    /**
+     * The elements which the transaction removes, or changes so that they no longer match, while it reads the sorted
+     * results of a query are left out as they are reached, as for an unsorted query. They are checked where the
+     * transaction had a change when a graph query began, or a change of the vertex's relations when a vertex query
+     * began.
+     */
+    @Test
+    public void testQueriesSortedInMemoryLeaveOutTheElementsRemovedWhileTheyAreRead() {
+        final PropertyKey kind = makeKey("kind", String.class);
+        makeKey("name", String.class);
+        mgmt.makeEdgeLabel("road").multiplicity(Multiplicity.MULTI).make();
+        mgmt.buildIndex("verticesByKind", Vertex.class).addKey(kind).buildCompositeIndex();
+        finishSchema();
+        final Vertex from = tx.addVertex("kind", "q");
+        for (final String name : Arrays.asList("a", "b", "c", "d", "e", "f", "g", "h")) {
+            from.addEdge("road", tx.addVertex("kind", "p", "name", name), "name", name);
+        }
+        newTx();
+        tx.addVertex("name", "unrelated");
+        final List<Object> names = new ArrayList<>();
+        for (final JanusGraphVertex vertex : tx.query().has("kind", "p").orderBy("name", asc).vertices()) {
+            names.add(vertex.value("name"));
+            if (names.size() == 1) {
+                tx.traversal().V().has("kind", "p").has("name", "g").next().remove();
+            }
+        }
+        assertEquals(Arrays.asList("a", "b", "c", "d", "e", "f", "h"), names);
+        tx.rollback();
+        newTx();
+
+        //and so are those which it changes so that they no longer match
+        tx.addVertex("name", "unrelated");
+        names.clear();
+        for (final JanusGraphVertex vertex : tx.query().has("kind", "p").orderBy("name", asc).vertices()) {
+            names.add(vertex.value("name"));
+            if (names.size() == 1) {
+                tx.traversal().V().has("kind", "p").has("name", "g").property("kind", "z").iterate();
+            }
+        }
+        assertEquals(Arrays.asList("a", "b", "c", "d", "e", "f", "h"), names);
+        tx.rollback();
+        newTx();
+
+        //and so are the edges of a vertex whose relations the transaction changed
+        final JanusGraphVertex source = (JanusGraphVertex) tx.traversal().V(from).next();
+        source.property("name", "source");
+        final List<Object> edgeNames = new ArrayList<>();
+        for (final JanusGraphEdge edge : source.query().labels("road").orderBy("name", asc).edges()) {
+            edgeNames.add(edge.value("name"));
+            if (edgeNames.size() == 1) {
+                tx.traversal().V(source).outE("road").has("name", "g").next().remove();
+            }
+        }
+        assertEquals(Arrays.asList("a", "b", "c", "d", "e", "f", "h"), edgeNames);
+        tx.rollback();
+    }
+
     @Test
     public void testUpdateForkEdgePropertyThenRemoveEdge() {
         initializeGraphWithVerticesAndEdges();
 
@@ -248,13 +248,26 @@ private final class PreSortingIterator implements CloseableIterator<R> {
 
         private final Iterator<R> iterator;
 
+        /*
+         * Sorts what the backend returns, once it has left out the elements which the transaction removed, as the
+         * order values of a removed vertex can't be read. getFilterIterator leaves out the other elements which the
+         * transaction deleted, such as those which it changed so that they no longer match, as they are reached, as
+         * for an unsorted query, so that a change which the caller makes while it reads the results is seen.
+         */
         private PreSortingIterator(BackendQueryHolder<B> backendQueryHolder) {
-            List<R> all = new ArrayList<>();
-            executor.execute(query,
+            final List<R> all = new ArrayList<>();
+            final Iterator<R> results = executor.execute(query,
                 backendQueryHolder.getBackendQuery().updateLimit(MAX_SORT_ITERATION),
-                backendQueryHolder.getExecutionInfo(),backendQueryHolder.getProfiler())
-                .forEachRemaining(all::add);
-            if (all.size() >= MAX_SORT_ITERATION)
+                backendQueryHolder.getExecutionInfo(),backendQueryHolder.getProfiler());
+            int fetched = 0;
+            while (results.hasNext()) {
+                final R result = results.next();
+                fetched++;
+                if (!result.isRemoved()) {
+                    all.add(result);
+                }
+            }
+            if (fetched >= MAX_SORT_ITERATION)
                 throw new QueryException("Could not execute query since pre-sorting requires fetching more than " +
                         MAX_SORT_ITERATION + " elements. Consider rewriting the query to exploit sort orders");
             all.sort(query.getSortOrder());
 
@@ -33,6 +33,7 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -105,6 +106,19 @@ public void asksNothingOfABackendWhichDoesntSort() {
         assertNull(executor.lastValue);
     }
 
+    //An element which the transaction removed, whose order value can't be read, is left out before the others are
+    //sorted
+    @Test
+    public void leavesOutTheRemovedElementsBeforeSortingWhatTheBackendReturns() {
+        final List<JanusGraphElement> stored = elements(8L, 6L, 4L);
+        final JanusGraphElement removed = mock(JanusGraphElement.class);
+        doReturn(true).when(removed).isRemoved();
+        doThrow(new IllegalStateException("The vertex was removed")).when(removed).valueOrNull(key);
+        stored.add(1, removed);
+        final Executor executor = new Executor(elements(), stored);
+        assertEquals(Arrays.asList(stored.get(0), stored.get(2), stored.get(3)), run(query(true, 10, false), executor));
+    }
+
     private List<JanusGraphElement> run(ElementQuery<JanusGraphElement, FakeBackendQuery> query, Executor executor) {
         final List<JanusGraphElement> result = new ArrayList<>();
         new QueryProcessor<>(query, executor).iterator().forEachRemaining(result::add);