diff --git a/tools/test/scenarios/fast.xml b/tools/test/scenarios/fast.xml
index 89fe845..3cfe2c6 100644
--- a/tools/test/scenarios/fast.xml
+++ b/tools/test/scenarios/fast.xml
@@ -13,7 +13,7 @@
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License.
   -->
-<scenario name="smoke" description="ONOS smoke test">
+<scenario name="fast" description="ONOS fast smoke test">
     <import file="${ONOS_SCENARIOS}/prerequisites.xml"/>
 
     <import file="${ONOS_SCENARIOS}/setup.xml"/>
diff --git a/tools/test/scenarios/net-pingall.xml b/tools/test/scenarios/net-pingall.xml
index 87c1322..100ceba 100644
--- a/tools/test/scenarios/net-pingall.xml
+++ b/tools/test/scenarios/net-pingall.xml
@@ -22,7 +22,7 @@
               exec="onos-check-apps ${OC1} drivers,openflow,proxyarp,fwd includes"/>
 
         <!-- TODO: take this out when initial pingall sweep is 100% -->
-        <step name="Initial-Ping-All" requires="Check-Apps"
+        <step name="Initial-Ping-All" requires="Check-Apps" unless="${ONOS_RF_BUG_FIXED}"
               exec="onos-mininet sendAndExpect py net.pingAll(1) --expect received"/>
 
         <step name="Ping-All-And-Verify" requires="Check-Apps,Initial-Ping-All"
