diff --git a/src/main/java/org/redisson/RedissonScoredSortedSet.java b/src/main/java/org/redisson/RedissonScoredSortedSet.java
index 8f5a5902d..1588fb381 100644
--- a/src/main/java/org/redisson/RedissonScoredSortedSet.java
+++ b/src/main/java/org/redisson/RedissonScoredSortedSet.java
@@ -411,6 +411,21 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
         return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGEBYSCORE, getName(), startValue, endValue);
     }
 
+    @Override
+    public Collection<V> valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore,
+            boolean endScoreInclusive) {
+        return get(valueRangeReversedAsync(startScore, startScoreInclusive, endScore, endScoreInclusive));
+    }
+
+    @Override
+    public Future<Collection<V>> valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore,
+            boolean endScoreInclusive) {
+        String startValue = value(BigDecimal.valueOf(startScore).toPlainString(), startScoreInclusive);
+        String endValue = value(BigDecimal.valueOf(endScore).toPlainString(), endScoreInclusive);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZREVRANGEBYSCORE, getName(), endValue, startValue);
+    }
+
+
     @Override
     public Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive) {
         return get(entryRangeAsync(startScore, startScoreInclusive, endScore, endScoreInclusive));
@@ -435,6 +450,18 @@ public class RedissonScoredSortedSet<V> extends RedissonExpirable implements RSc
         return commandExecutor.readAsync(getName(), codec, RedisCommands.ZRANGEBYSCORE, getName(), startValue, endValue, "LIMIT", offset, count);
     }
 
+    @Override
+    public Collection<V> valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count) {
+        return get(valueRangeReversedAsync(startScore, startScoreInclusive, endScore, endScoreInclusive, offset, count));
+    }
+
+    @Override
+    public Future<Collection<V>> valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count) {
+        String startValue = value(BigDecimal.valueOf(startScore).toPlainString(), startScoreInclusive);
+        String endValue = value(BigDecimal.valueOf(endScore).toPlainString(), endScoreInclusive);
+        return commandExecutor.readAsync(getName(), codec, RedisCommands.ZREVRANGEBYSCORE, getName(), endValue, startValue, "LIMIT", offset, count);
+    }
+
     @Override
     public Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count) {
         return get(entryRangeAsync(startScore, startScoreInclusive, endScore, endScoreInclusive, offset, count));
diff --git a/src/main/java/org/redisson/client/protocol/RedisCommands.java b/src/main/java/org/redisson/client/protocol/RedisCommands.java
index 36893e64b..5efc7df00 100644
--- a/src/main/java/org/redisson/client/protocol/RedisCommands.java
+++ b/src/main/java/org/redisson/client/protocol/RedisCommands.java
@@ -91,6 +91,7 @@ public interface RedisCommands {
     RedisStrictCommand<Integer> ZREMRANGEBYLEX = new RedisStrictCommand<Integer>("ZREMRANGEBYLEX", new IntegerReplayConvertor());
     RedisCommand<List<Object>> ZRANGEBYLEX = new RedisCommand<List<Object>>("ZRANGEBYLEX", new ObjectListReplayDecoder<Object>());
     RedisCommand<List<Object>> ZRANGEBYSCORE = new RedisCommand<List<Object>>("ZRANGEBYSCORE", new ObjectListReplayDecoder<Object>());
+    RedisCommand<List<Object>> ZREVRANGEBYSCORE = new RedisCommand<List<Object>>("ZREVRANGEBYSCORE", new ObjectListReplayDecoder<Object>());
     RedisCommand<List<ScoredEntry<Object>>> ZRANGE_ENTRY = new RedisCommand<List<ScoredEntry<Object>>>("ZRANGE", new ScoredSortedSetReplayDecoder<Object>());
     RedisCommand<List<ScoredEntry<Object>>> ZRANGEBYSCORE_ENTRY = new RedisCommand<List<ScoredEntry<Object>>>("ZRANGEBYSCORE", new ScoredSortedSetReplayDecoder<Object>());
     RedisCommand<ListScanResult<Object>> ZSCAN = new RedisCommand<ListScanResult<Object>>("ZSCAN", new NestedMultiDecoder(new ScoredSortedSetScanDecoder<Object>(), new ScoredSortedSetScanReplayDecoder()), ValueType.OBJECT);
diff --git a/src/main/java/org/redisson/core/RScoredSortedSet.java b/src/main/java/org/redisson/core/RScoredSortedSet.java
index bf37e97cb..ddaeef9b9 100644
--- a/src/main/java/org/redisson/core/RScoredSortedSet.java
+++ b/src/main/java/org/redisson/core/RScoredSortedSet.java
@@ -88,10 +88,14 @@ public interface RScoredSortedSet<V> extends RScoredSortedSetAsync<V>, Iterable<
 
     Collection<V> valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
 
+    Collection<V> valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
+
     Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
 
     Collection<V> valueRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
 
+    Collection<V> valueRangeReversed(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
+
     Collection<ScoredEntry<V>> entryRange(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
 
 }
diff --git a/src/main/java/org/redisson/core/RScoredSortedSetAsync.java b/src/main/java/org/redisson/core/RScoredSortedSetAsync.java
index e49857952..fe6ea081a 100644
--- a/src/main/java/org/redisson/core/RScoredSortedSetAsync.java
+++ b/src/main/java/org/redisson/core/RScoredSortedSetAsync.java
@@ -82,10 +82,14 @@ public interface RScoredSortedSetAsync<V> extends RExpirableAsync {
 
     Future<Collection<V>> valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
 
+    Future<Collection<V>> valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
+
     Future<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive);
 
     Future<Collection<V>> valueRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
 
+    Future<Collection<V>> valueRangeReversedAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
+
     Future<Collection<ScoredEntry<V>>> entryRangeAsync(double startScore, boolean startScoreInclusive, double endScore, boolean endScoreInclusive, int offset, int count);
 
 }
diff --git a/src/test/java/org/redisson/RedissonScoredSortedSetTest.java b/src/test/java/org/redisson/RedissonScoredSortedSetTest.java
index 9996ebb01..e5290ac8e 100644
--- a/src/test/java/org/redisson/RedissonScoredSortedSetTest.java
+++ b/src/test/java/org/redisson/RedissonScoredSortedSetTest.java
@@ -508,8 +508,8 @@ public class RedissonScoredSortedSetTest extends BaseTest {
     }
 
     @Test
-    public void testScoredSortedSetValueRange() {
-        RScoredSortedSet<String> set = redisson.<String>getScoredSortedSet("simple");
+    public void testScoredSortedSetValueRangeLimit() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
 
         set.add(0, "a");
         set.add(1, "b");
@@ -518,13 +518,54 @@ public class RedissonScoredSortedSetTest extends BaseTest {
         set.add(4, "e");
 
         Collection<String> r = set.valueRange(1, true, 4, false, 1, 2);
-        String[] a = r.toArray(new String[0]);
-        Assert.assertArrayEquals(new String[]{"c", "d"}, a);
+        assertThat(r).containsExactly("c", "d");
+    }
+
+    @Test
+    public void testScoredSortedSetValueRange() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+
+        set.add(0, "a");
+        set.add(1, "b");
+        set.add(2, "c");
+        set.add(3, "d");
+        set.add(4, "e");
+
+        Collection<String> r = set.valueRange(1, true, 4, false);
+        assertThat(r).containsExactly("b", "c", "d");
+    }
+
+    @Test
+    public void testScoredSortedSetValueRangeReversedLimit() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+
+        set.add(0, "a");
+        set.add(1, "b");
+        set.add(2, "c");
+        set.add(3, "d");
+        set.add(4, "e");
+
+        Collection<String> r = set.valueRangeReversed(1, true, 4, false, 1, 2);
+        assertThat(r).containsExactly("c", "b");
+    }
+
+    @Test
+    public void testScoredSortedSetValueRangeReversed() {
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
+
+        set.add(0, "a");
+        set.add(1, "b");
+        set.add(2, "c");
+        set.add(3, "d");
+        set.add(4, "e");
+
+        Collection<String> r = set.valueRangeReversed(1, true, 4, false);
+        assertThat(r).containsExactly("d", "c", "b");
     }
 
     @Test
     public void testScoredSortedSetEntryRange() {
-        RScoredSortedSet<String> set = redisson.<String>getScoredSortedSet("simple");
+        RScoredSortedSet<String> set = redisson.getScoredSortedSet("simple");
 
         set.add(0, "a");
         set.add(1, "b");