diff --git oak-doc/src/site/site.xml oak-doc/src/site/site.xml
index 93d8a40..80a9cbc 100644
--- oak-doc/src/site/site.xml
+++ oak-doc/src/site/site.xml
@@ -84,6 +84,9 @@ under the License.
         <href>/</href>
       </topBarIcon>
       <sideBarEnabled>true</sideBarEnabled>
+      <googleSearch>
+        <sitesearch/>
+      </googleSearch>
       <gitHub>
         <projectId>apache/jackrabbit-oak</projectId>
         <ribbonOrientation>right</ribbonOrientation>
diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndex.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndex.java
index d9fb2f1..c34a6b0 100644
--- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndex.java
+++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LuceneIndex.java
@@ -349,23 +349,31 @@ public class LuceneIndex implements AdvanceFulltextQueryIndex {
                         TopDocs docs;
                         long time = System.currentTimeMillis();
                         checkForIndexVersionChange(searcher);
-                        if (lastDoc != null) {
-                            LOG.debug("loading the next {} entries for query {}", nextBatchSize, query);
-                            docs = searcher.searchAfter(lastDoc, query, nextBatchSize);
-                        } else {
-                            LOG.debug("loading the first {} entries for query {}", nextBatchSize, query);
-                            docs = searcher.search(query, nextBatchSize);
-                        }
-                        time = System.currentTimeMillis() - time;
-                        LOG.debug("... took {} ms", time);
-                        nextBatchSize = (int) Math.min(nextBatchSize * 2L, 100000);
-
-                        for (ScoreDoc doc : docs.scoreDocs) {
-                            LuceneResultRow row = convertToRow(doc, searcher);
-                            if (row != null) {
-                                queue.add(row);
+                        while (true) {
+                            if (lastDoc != null) {
+                                LOG.debug("loading the next {} entries for query {}", nextBatchSize, query);
+                                docs = searcher.searchAfter(lastDoc, query, nextBatchSize);
+                            } else {
+                                LOG.debug("loading the first {} entries for query {}", nextBatchSize, query);
+                                docs = searcher.search(query, nextBatchSize);
+                            }
+                            time = System.currentTimeMillis() - time;
+                            LOG.debug("... took {} ms", time);
+                            nextBatchSize = (int) Math.min(nextBatchSize * 2L, 100000);
+
+                            for (ScoreDoc doc : docs.scoreDocs) {
+                                LuceneResultRow row = convertToRow(doc, searcher);
+                                if (row != null) {
+                                    queue.add(row);
+                                }
+                                lastDocToRecord = doc;
+                            }
+
+                            if (queue.isEmpty() && docs.scoreDocs.length > 0) {
+                                lastDoc = lastDocToRecord;
+                            } else {
+                                break;
                             }
-                            lastDocToRecord = doc;
                         }
                     } else if (luceneRequestFacade.getLuceneRequest() instanceof SpellcheckHelper.SpellcheckQuery) {
                         SpellcheckHelper.SpellcheckQuery spellcheckQuery = (SpellcheckHelper.SpellcheckQuery) luceneRequestFacade.getLuceneRequest();
diff --git oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java
index ec9c6d6..a81381e 100644
--- oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java
+++ oak-lucene/src/main/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndex.java
@@ -291,14 +291,23 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati
                         path = "/";
                     }
                     if (pr.isPathTransformed()) {
+                        String originalPath = path;
                         path = pr.transformPath(path);
+
+                        if (path == null){
+                            LOG.trace("Ignoring path {} : Transformation returned null", originalPath);
+                            return null;
+                        }
+
                         // avoid duplicate entries
-                        if (path == null || seenPaths.contains(path)) {
+                        if (seenPaths.contains(path)){
+                            LOG.trace("Ignoring path {} : Duplicate post transformation", originalPath);
                             return null;
                         }
                         seenPaths.add(path);
                     }
 
+                    LOG.trace("Matched path {}", path);
                     return new LuceneResultRow(path, doc.score);
                 }
                 return null;
@@ -334,30 +343,40 @@ public class LucenePropertyIndex implements AdvancedQueryIndex, QueryIndex, Nati
 
                         TopDocs docs;
                         long start = PERF_LOGGER.start();
-                        if (lastDoc != null) {
-                            LOG.debug("loading the next {} entries for query {}", nextBatchSize, query);
-                            if (sort == null) {
-                                docs = searcher.searchAfter(lastDoc, query, nextBatchSize);
+                        while (true) {
+                            if (lastDoc != null) {
+                                LOG.debug("loading the next {} entries for query {}", nextBatchSize, query);
+                                if (sort == null) {
+                                    docs = searcher.searchAfter(lastDoc, query, nextBatchSize);
+                                } else {
+                                    docs = searcher.searchAfter(lastDoc, query, nextBatchSize, sort);
+                                }
                             } else {
-                                docs = searcher.searchAfter(lastDoc, query, nextBatchSize, sort);
+                                LOG.debug("loading the first {} entries for query {}", nextBatchSize, query);
+                                if (sort == null) {
+                                    docs = searcher.search(query, nextBatchSize);
+                                } else {
+                                    docs = searcher.search(query, nextBatchSize, sort);
+                                }
                             }
-                        } else {
-                            LOG.debug("loading the first {} entries for query {}", nextBatchSize, query);
-                            if (sort == null) {
-                                docs = searcher.search(query, nextBatchSize);
-                            } else {
-                                docs = searcher.search(query, nextBatchSize, sort);
+                            PERF_LOGGER.end(start, -1, "...");
+                            nextBatchSize = (int) Math.min(nextBatchSize * 2L, 100000);
+
+                            for (ScoreDoc doc : docs.scoreDocs) {
+                                LuceneResultRow row = convertToRow(doc, searcher);
+                                if (row != null) {
+                                    queue.add(row);
+                                }
+                                lastDocToRecord = doc;
                             }
-                        }
-                        PERF_LOGGER.end(start, -1, "...");
-                        nextBatchSize = (int) Math.min(nextBatchSize * 2L, 100000);
 
-                        for (ScoreDoc doc : docs.scoreDocs) {
-                            LuceneResultRow row = convertToRow(doc, searcher);
-                            if (row != null) {
-                                queue.add(row);
+                            if (queue.isEmpty() && docs.scoreDocs.length > 0) {
+                                //queue is still emoty but more results can be fetched
+                                //from Lucene so still continue
+                                lastDoc = lastDocToRecord;
+                            } else {
+                                break;
                             }
-                            lastDocToRecord = doc;
                         }
                     } else if (luceneRequestFacade.getLuceneRequest() instanceof SpellcheckHelper.SpellcheckQuery) {
                         SpellcheckHelper.SpellcheckQuery spellcheckQuery = (SpellcheckHelper.SpellcheckQuery) luceneRequestFacade.getLuceneRequest();
diff --git oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java
index 75945a9..95e57fe 100644
--- oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java
+++ oak-lucene/src/test/java/org/apache/jackrabbit/oak/plugins/index/lucene/LucenePropertyIndexTest.java
@@ -1280,6 +1280,37 @@ public class LucenePropertyIndexTest extends AbstractQueryTest {
         assertQuery("select * from [nt:base] where CONTAINS(*, 'jumping')", Collections.<String>emptyList());
     }
 
+    @Test
+    public void relativePropertyAndCursor() throws Exception{
+        // Index Definition
+        Tree idx = createIndex("test1", of("propa", "propb"));
+        TestUtil.useV2(idx);
+        idx.setProperty(LuceneIndexConstants.FULL_TEXT_ENABLED, true);
+
+        Tree propNode = idx.addChild(PROP_NODE);
+
+        // property definition for index test1
+        Tree propA = propNode.addChild("propa");
+        propA.setProperty(LuceneIndexConstants.PROP_TYPE, PropertyType.TYPENAME_STRING);
+        propA.setProperty(LuceneIndexConstants.FIELD_BOOST, 2.0);
+
+        root.commit();
+
+        // create test data with 1 more than batch size
+        //with boost set we ensure that correct result comes *after* the batch size of results
+        Tree test = root.getTree("/").addChild("test");
+        root.commit();
+        for (int i = 0; i < LucenePropertyIndex.LUCENE_QUERY_BATCH_SIZE; i++) {
+            test.addChild("a"+i).addChild("doNotInclude").setProperty("propa", "foo");
+        }
+        test.addChild("b").addChild("jcr:content").setProperty("propb", "foo");
+        root.commit();
+
+        String queryString = "/jcr:root//element(*, nt:base)[jcr:contains(jcr:content, 'foo' )]";
+
+        assertQuery(queryString, "xpath", asList("/test/b"));
+    }
+
     private Tree createFileNode(Tree tree, String name, String content, String mimeType){
         Tree jcrContent = tree.addChild(name).addChild(JCR_CONTENT);
         jcrContent.setProperty(JcrConstants.JCR_DATA, content.getBytes());
