diff --git a/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs b/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs
index adc4612a34..d678ce239d 100644
--- a/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs
+++ b/nym-wallet/src-tauri/src/operations/mixnet/rewards.rs
@@ -2,6 +2,7 @@ use crate::error::BackendError;
 use crate::nymd_client;
 use crate::state::State;
 use mixnet_contract_common::IdentityKey;
+use nym_types::transaction::TransactionExecuteResult;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use validator_client::nymd::Fee;
@@ -10,22 +11,36 @@ use validator_client::nymd::Fee;
 pub async fn claim_operator_reward(
     fee: Option<Fee>,
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(">>> Claim operator reward");
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_claim_operator_reward(fee)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
 
 #[tauri::command]
 pub async fn compound_operator_reward(
     fee: Option<Fee>,
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(">>> Compound operator reward");
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_compound_operator_reward(fee)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
 
 #[tauri::command]
@@ -33,11 +48,21 @@ pub async fn claim_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(
+        ">>> Claim delegator reward: identity_key = {}",
+        mix_identity
+    );
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_claim_delegator_reward(mix_identity, fee)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
 
 #[tauri::command]
@@ -45,9 +70,19 @@ pub async fn compound_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(
+        ">>> Compound delegator reward: identity_key = {}",
+        mix_identity
+    );
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_compound_delegator_reward(mix_identity, fee)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
diff --git a/nym-wallet/src-tauri/src/operations/vesting/rewards.rs b/nym-wallet/src-tauri/src/operations/vesting/rewards.rs
index e6b27fa78f..1434bc1fbe 100644
--- a/nym-wallet/src-tauri/src/operations/vesting/rewards.rs
+++ b/nym-wallet/src-tauri/src/operations/vesting/rewards.rs
@@ -2,6 +2,7 @@ use crate::error::BackendError;
 use crate::nymd_client;
 use crate::state::State;
 use mixnet_contract_common::IdentityKey;
+use nym_types::transaction::TransactionExecuteResult;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 use validator_client::nymd::Fee;
@@ -9,22 +10,36 @@ use validator_client::nymd::Fee;
 #[tauri::command]
 pub async fn vesting_claim_operator_reward(
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(">>> Vesting account: claim operator reward");
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_vesting_claim_operator_reward(None)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
 
 #[tauri::command]
 pub async fn vesting_compound_operator_reward(
     fee: Option<Fee>,
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(">>> Vesting account: compound operator reward");
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_vesting_compound_operator_reward(fee)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
 
 #[tauri::command]
@@ -32,11 +47,21 @@ pub async fn vesting_claim_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(
+        ">>> Vesting account: claim delegator reward: identity_key = {}",
+        mix_identity
+    );
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_vesting_claim_delegator_reward(mix_identity, fee)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
 
 #[tauri::command]
@@ -44,9 +69,19 @@ pub async fn vesting_compound_delegator_reward(
     mix_identity: IdentityKey,
     fee: Option<Fee>,
     state: tauri::State<'_, Arc<RwLock<State>>>,
-) -> Result<(), BackendError> {
-    nymd_client!(state)
+) -> Result<TransactionExecuteResult, BackendError> {
+    log::info!(
+        ">>> Vesting account: compound delegator reward: identity_key = {}",
+        mix_identity
+    );
+    let denom_minor = state.read().await.current_network().denom();
+    let res = nymd_client!(state)
         .execute_vesting_compound_delegator_reward(mix_identity, fee)
         .await?;
-    Ok(())
+    log::info!("<<< tx hash = {}", res.transaction_hash);
+    log::trace!("<<< {:?}", res);
+    Ok(TransactionExecuteResult::from_execute_result(
+        res,
+        denom_minor.as_ref(),
+    )?)
 }
diff --git a/nym-wallet/src/requests/rewards.ts b/nym-wallet/src/requests/rewards.ts
index 4a0aa23ef5..3a112f7aa8 100644
--- a/nym-wallet/src/requests/rewards.ts
+++ b/nym-wallet/src/requests/rewards.ts
@@ -1,7 +1,14 @@
 import { invokeWrapper } from './wrapper';
+import { TransactionExecuteResult } from '@nymproject/types';
 
-export const claimDelegatorRewards = async (mixIdentity: string): Promise<void> =>
-  invokeWrapper('claim_delegator_reward', { mixIdentity });
+export const claimOperatorRewards = async () =>
+  invokeWrapper<TransactionExecuteResult>('claim_operator_reward');
 
-export const compoundDelegatorRewards = async (mixIdentity: String): Promise<void> =>
-  invokeWrapper('compound_delegator_reward', { mixIdentity });
+export const compoundOperatorRewards = async () =>
+  invokeWrapper<TransactionExecuteResult>('compound_operator_reward');
+
+export const claimDelegatorRewards = async (mixIdentity: string) =>
+  invokeWrapper<TransactionExecuteResult>('claim_delegator_reward', { mixIdentity });
+
+export const compoundDelegatorRewards = async (mixIdentity: String) =>
+  invokeWrapper<TransactionExecuteResult>('compound_delegator_reward', { mixIdentity });
diff --git a/nym-wallet/src/requests/vesting.ts b/nym-wallet/src/requests/vesting.ts
index 6312fb4fb0..5e8066c785 100644
--- a/nym-wallet/src/requests/vesting.ts
+++ b/nym-wallet/src/requests/vesting.ts
@@ -104,8 +104,14 @@ export const vestingBond = async (args: { type: EnumNodeType } & (TBondMixNodeAr
   return vestingBondGateway(other as TBondGatewayArgs);
 };
 
-export const vestingClaimDelegatorRewards = async (mixIdentity: string): Promise<void> =>
-  invokeWrapper('vesting_claim_delegator_reward', { mixIdentity });
+export const vestingClaimOperatorRewards = async () =>
+  invokeWrapper<TransactionExecuteResult>('vesting_claim_operator_reward');
 
-export const vestingCompoundDelegatorRewards = async (mixIdentity: string): Promise<void> =>
-  invokeWrapper('vesting_compound_delegator_reward', { mixIdentity });
+export const vestingCompoundOperatorRewards = async () =>
+  invokeWrapper<TransactionExecuteResult>('vesting_compound_operator_reward');
+
+export const vestingClaimDelegatorRewards = async (mixIdentity: string) =>
+  invokeWrapper<TransactionExecuteResult>('vesting_claim_delegator_reward', { mixIdentity });
+
+export const vestingCompoundDelegatorRewards = async (mixIdentity: string) =>
+  invokeWrapper<TransactionExecuteResult>('vesting_compound_delegator_reward', { mixIdentity });