diff --git a/rs/nns/governance/canister/canister.rs b/rs/nns/governance/canister/canister.rs
index f9be2692046f..3aa4fb24aa21 100644
--- a/rs/nns/governance/canister/canister.rs
+++ b/rs/nns/governance/canister/canister.rs
@@ -745,14 +745,14 @@ fn list_node_provider_rewards() {
 fn list_node_provider_rewards_(
     req: ListNodeProviderRewardsRequest,
 ) -> ListNodeProviderRewardsResponse {
-    let rewards = governance().list_node_provider_rewards(5, req.page);
+    let (next_page, rewards) = governance().list_node_provider_rewards(5, req.page);
 
     ListNodeProviderRewardsResponse {
         rewards: rewards
             .into_iter()
             .map(MonthlyNodeProviderRewards::from)
             .collect(),
-        next_page: None,
+        next_page,
     }
 }
 
diff --git a/rs/nns/governance/src/governance.rs b/rs/nns/governance/src/governance.rs
index 04ff91dc2b32..41598ae398f7 100644
--- a/rs/nns/governance/src/governance.rs
+++ b/rs/nns/governance/src/governance.rs
@@ -4316,9 +4316,10 @@ impl Governance {
         &self,
         limit: u64,
         page: Option<u32>,
-    ) -> Vec<MonthlyNodeProviderRewards> {
+    ) -> (Option<u32>, Vec<MonthlyNodeProviderRewards>) {
         let limit = limit.min(MAX_LIST_NODE_PROVIDER_REWARDS_RESULTS);
-        list_node_provider_rewards(limit, page)
+        let (next_page, rewards) = list_node_provider_rewards(limit, page);
+        let rewards = rewards
             .into_iter()
             .map(|archived| match archived.version {
                 Some(archived_monthly_node_provider_rewards::Version::Version1(v1)) => {
@@ -4326,7 +4327,8 @@ impl Governance {
                 }
                 _ => panic!("Should not be possible!"),
             })
-            .collect()
+            .collect();
+        (next_page, rewards)
     }
 
     pub fn get_most_recent_monthly_node_provider_rewards(
diff --git a/rs/nns/governance/src/node_provider_rewards.rs b/rs/nns/governance/src/node_provider_rewards.rs
index 32c4ca7688d2..6b503ac40ce5 100644
--- a/rs/nns/governance/src/node_provider_rewards.rs
+++ b/rs/nns/governance/src/node_provider_rewards.rs
@@ -34,7 +34,7 @@ pub(crate) fn latest_node_provider_rewards() -> Option<ArchivedMonthlyNodeProvid
 pub(crate) fn list_node_provider_rewards(
     limit: u64,
     page: Option<u32>,
-) -> Vec<ArchivedMonthlyNodeProviderRewards> {
+) -> (Option<u32>, Vec<ArchivedMonthlyNodeProviderRewards>) {
     use dfn_core::println;
     let page = page.unwrap_or(0);
 
@@ -45,10 +45,16 @@ pub(crate) fn list_node_provider_rewards(
         let len = log.len();
         let end_range = len.saturating_sub(page as u64 * limit);
         let start_range = end_range.saturating_sub(limit);
-        (start_range..end_range)
+        let rewards = (start_range..end_range)
             .rev()
             .flat_map(|index| log.get(index))
-            .collect()
+            .collect();
+
+        if start_range == 0 {
+            (None, rewards)
+        } else {
+            (Some(page + 1), rewards)
+        }
     })
 }
 
diff --git a/rs/nns/integration_tests/src/node_provider_remuneration.rs b/rs/nns/integration_tests/src/node_provider_remuneration.rs
index db37ed530e00..2fcc1514a56b 100644
--- a/rs/nns/integration_tests/src/node_provider_remuneration.rs
+++ b/rs/nns/integration_tests/src/node_provider_remuneration.rs
@@ -190,13 +190,6 @@ fn test_list_node_provider_rewards() {
         state_machine.advance_time(Duration::from_secs(ONE_MONTH_SECONDS + 1));
         state_machine.advance_time(Duration::from_secs(60));
         state_machine.tick();
-        state_machine.tick();
-        state_machine.tick();
-        state_machine.tick();
-        state_machine.tick();
-        state_machine.tick();
-        state_machine.tick();
-        state_machine.tick();
 
         let rewards = nns_get_most_recent_monthly_node_provider_rewards(&state_machine).unwrap();
 
@@ -212,12 +205,72 @@ fn test_list_node_provider_rewards() {
     );
 
     assert_eq!(response.rewards.len(), 5);
-    //
-    // let received_ts: Vec<u64> = response.rewards.iter().map(|r| r.timestamp).collect();
-    // let expected_ts: Vec<u64> = minted_rewards.iter().map(|r| r.timestamp).collect();
-    //
-    // assert_eq!(received_ts, expected_ts[8..]);
-    assert_eq!(response.rewards, minted_rewards[8..]);
+
+    let received_ts: Vec<u64> = response.rewards.iter().map(|r| r.timestamp).collect();
+    let expected_ts: Vec<u64> = minted_rewards.iter().map(|r| r.timestamp).collect();
+
+    println!(
+        "{:?}",
+        expected_ts.iter().rev().cloned().collect::<Vec<_>>()
+    );
+
+    assert_eq!(
+        received_ts,
+        expected_ts[8..13]
+            .into_iter()
+            .rev()
+            .cloned()
+            .collect::<Vec<_>>()
+    );
+
+    // check rewards are as expected
+    assert_eq!(
+        response.rewards,
+        minted_rewards[8..13]
+            .into_iter()
+            .rev()
+            .cloned()
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(response.next_page, Some(1));
+
+    let response = nns_list_node_provider_rewards(
+        &state_machine,
+        ListNodeProviderRewardsRequest {
+            page: response.next_page,
+            date_filter: None,
+        },
+    );
+
+    let received_ts: Vec<u64> = response.rewards.iter().map(|r| r.timestamp).collect();
+    assert_eq!(
+        received_ts,
+        expected_ts[3..8]
+            .into_iter()
+            .rev()
+            .cloned()
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(response.next_page, Some(2));
+
+    let response = nns_list_node_provider_rewards(
+        &state_machine,
+        ListNodeProviderRewardsRequest {
+            page: response.next_page,
+            date_filter: None,
+        },
+    );
+
+    let received_ts: Vec<u64> = response.rewards.iter().map(|r| r.timestamp).collect();
+    assert_eq!(
+        received_ts,
+        expected_ts[0..3]
+            .into_iter()
+            .rev()
+            .cloned()
+            .collect::<Vec<_>>()
+    );
+    assert_eq!(response.next_page, None);
 }
 #[test]
 fn test_automated_node_provider_remuneration() {