diff --git a/tempest/api/compute/servers/test_server_actions.py b/tempest/api/compute/servers/test_server_actions.py
index 9b30582..b4692f8 100644
--- a/tempest/api/compute/servers/test_server_actions.py
+++ b/tempest/api/compute/servers/test_server_actions.py
@@ -41,46 +41,17 @@
         min_microversion = '2.60'
 
     def setUp(self):
-        # NOTE(afazekas): Normally we use the same server with all test cases,
-        # but if it has an issue, we build a new one
         super().setUp()
-        # Check if the server is in a clean state after test
-        try:
-            self.validation_resources = self.get_class_validation_resources(
-                self.os_primary)
-            # _test_rebuild_server test compares ip address attached to the
-            # server before and after the rebuild, in order to avoid
-            # a situation when a newly created server doesn't have a floating
-            # ip attached at the beginning of the test_rebuild_server let's
-            # make sure right here the floating ip is attached
-            waiters.wait_for_server_floating_ip(
-                self.client,
-                self.client.show_server(self.server_id)['server'],
-                self.validation_resources['floating_ip'])
-            waiters.wait_for_server_status(self.client,
-                                           self.server_id, 'ACTIVE')
-        except lib_exc.NotFound:
-            # The server was deleted by previous test, create a new one
-            # Use class level validation resources to avoid them being
-            # deleted once a test is over
-            self.validation_resources = self.get_class_validation_resources(
-                self.os_primary)
-            server = self.create_test_server(
-                validatable=True,
-                validation_resources=self.validation_resources,
-                wait_until='SSHABLE')
-            self.__class__.server_id = server['id']
-        except Exception:
-            # Rebuild server if something happened to it during a test
-            self.__class__.server_id = self.recreate_server(
-                self.server_id, validatable=True, wait_until='SSHABLE')
-
-    def tearDown(self):
-        super(ServerActionsBase, self).tearDown()
-        # NOTE(zhufl): Because server_check_teardown will raise Exception
-        # which will prevent other cleanup steps from being executed, so
-        # server_check_teardown should be called after super's tearDown.
-        self.server_check_teardown()
+        # Instead of reusing an instance which had been created before a new
+        # instance is created in favour of increasing stability of tests.
+        self.validation_resources = self.get_test_validation_resources(
+            self.os_primary)
+        server = self.create_test_server(
+            validatable=True,
+            validation_resources=self.validation_resources,
+            wait_until='SSHABLE')
+        self.server_id = server['id']
+        self.addCleanup(self.delete_server, self.server_id)
 
     @classmethod
     def setup_credentials(cls):
@@ -92,20 +63,14 @@
         super(ServerActionsBase, cls).setup_clients()
         cls.client = cls.servers_client
 
-    @classmethod
-    def resource_setup(cls):
-        super(ServerActionsBase, cls).resource_setup()
-        cls.server_id = cls.recreate_server(None, validatable=True,
-                                            wait_until='SSHABLE')
-
-    def _test_reboot_server(self, reboot_type):
+    def _test_reboot_server(self, server_id, reboot_type):
         if CONF.validation.run_validation:
             # Get the time the server was last rebooted,
-            server = self.client.show_server(self.server_id)['server']
+            server = self.client.show_server(server_id)['server']
             linux_client = remote_client.RemoteClient(
                 self.get_server_ip(server, self.validation_resources),
                 self.ssh_user,
-                self.password,
+                getattr(self, "password", None),
                 self.validation_resources['keypair']['private_key'],
                 server=server,
                 servers_client=self.client)
@@ -115,14 +80,14 @@
             # in a server
             linux_client.exec_command("sync")
 
-        self.reboot_server(self.server_id, type=reboot_type)
+        self.reboot_server(server_id, type=reboot_type)
 
         if CONF.validation.run_validation:
             # Log in and verify the boot time has changed
             linux_client = remote_client.RemoteClient(
                 self.get_server_ip(server, self.validation_resources),
                 self.ssh_user,
-                self.password,
+                getattr(self, "password", None),
                 self.validation_resources['keypair']['private_key'],
                 server=server,
                 servers_client=self.client)
@@ -131,6 +96,22 @@
                                '%s > %s' % (new_boot_time, boot_time))
 
     def _test_rebuild_server(self, server_id):
+
+        def floating_ip_ready():
+            addresses = self.client.show_server(
+                server_id)['server']['addresses']
+            self.assertTrue(
+                self.validation_resources["floating_ip"]["ip"] in
+                [addr["addr"] for net in addresses.values() for addr in net]
+            )
+
+        # NOTE(pas-ha) we now always create 'validating' server
+        # create_server only waits for ACTIVE state, but floating ip
+        # may be assigned a bit later.
+        # as we compare network addresses before and after rebuild,
+        # need to ensure we remember the floating one too.
+        self.wait_for(floating_ip_ready)
+
         # Get the IPs the server has before rebuilding it
         original_addresses = (self.client.show_server(server_id)['server']
                               ['addresses'])
@@ -231,13 +212,7 @@
         The server's password should be set to the provided password and
         the user can authenticate with the new password.
         """
-        # Since this test messes with the password and makes the
-        # server unreachable, it should create its own server
-        newserver = self.create_test_server(
-            validatable=True,
-            validation_resources=self.validation_resources,
-            wait_until='ACTIVE')
-        self.addCleanup(self.delete_server, newserver['id'])
+        newserver = self.client.show_server(self.server_id)['server']
         # The server's password should be set to the provided password
         new_password = 'Newpass1234'
         self.client.change_password(newserver['id'], adminPass=new_password)
@@ -261,7 +236,7 @@
 
         The server should be power cycled.
         """
-        self._test_reboot_server('HARD')
+        self._test_reboot_server(self.server_id, 'HARD')
 
     @decorators.idempotent_id('aaa6cdf3-55a7-461a-add9-1c8596b9a07c')
     def test_rebuild_server(self):
@@ -269,18 +244,7 @@
 
         The server should be rebuilt using the provided image and data.
         """
-        tenant_network = self.get_tenant_network()
-        _, servers = compute.create_test_server(
-            self.os_primary,
-            wait_until='ACTIVE',
-            tenant_network=tenant_network)
-        server = servers[0]
-
-        self.addCleanup(waiters.wait_for_server_termination,
-                        self.client, server['id'])
-        self.addCleanup(self.client.delete_server, server['id'])
-
-        self._test_rebuild_server(server_id=server['id'])
+        self._test_rebuild_server(self.server_id)
 
     @decorators.idempotent_id('1499262a-9328-4eda-9068-db1ac57498d2')
     @testtools.skipUnless(CONF.compute_feature_enabled.resize,
@@ -386,7 +350,7 @@
     @decorators.idempotent_id('1d1c9104-1b0a-11e7-a3d4-fa163e65f5ce')
     def test_remove_server_all_security_groups(self):
         """Test removing all security groups from server"""
-        server = self.create_test_server(wait_until='ACTIVE')
+        server = self.client.show_server(self.server_id)['server']
 
         # Remove all Security group
         self.client.remove_security_group(
@@ -403,17 +367,7 @@
         The server in stop state should be rebuilt using the provided
         image and remain in SHUTOFF state.
         """
-        tenant_network = self.get_tenant_network()
-        _, servers = compute.create_test_server(
-            self.os_primary,
-            wait_until='ACTIVE',
-            tenant_network=tenant_network)
-        server = servers[0]
-
-        self.addCleanup(waiters.wait_for_server_termination,
-                        self.client, server['id'])
-        self.addCleanup(self.client.delete_server, server['id'])
-        server = self.client.show_server(server['id'])['server']
+        server = self.client.show_server(self.server_id)['server']
         old_image = server['image']['id']
         new_image = (self.image_ref_alt
                      if old_image == self.image_ref else self.image_ref)
@@ -449,26 +403,13 @@
         """
         # create a new volume and attach it to the server
         volume = self.create_volume(wait_for_available=False)
-        network = self.get_tenant_network()
-        validation_resources = self.get_test_validation_resources(
-            self.os_primary)
-        _, servers = compute.create_test_server(
-            self.os_primary, tenant_network=network,
-            validatable=True,
-            validation_resources=validation_resources,
-            wait_until='SSHABLE')
-        server = servers[0]
-        self.addCleanup(waiters.wait_for_server_termination,
-                        self.client, server['id'])
-        self.addCleanup(self.client.delete_server, server['id'])
-
-        server = self.client.show_server(server['id'])['server']
+        server = self.client.show_server(self.server_id)['server']
         waiters.wait_for_volume_resource_status(self.volumes_client,
                                                 volume['id'], 'available')
         self.attach_volume(server, volume)
 
         # run general rebuild test
-        self._test_rebuild_server(server_id=server['id'])
+        self._test_rebuild_server(self.server_id)
 
         # make sure the volume is attached to the instance after rebuild
         vol_after_rebuild = self.volumes_client.show_volume(volume['id'])
@@ -492,6 +433,7 @@
             kwargs.update({'validatable': True,
                            'validation_resources': self.validation_resources})
         server = self.create_test_server(**kwargs)
+        self.addCleanup(self.delete_server, server['id'])
 
         # NOTE(mgoddard): Get detailed server to ensure addresses are present
         # in fixed IP case.
@@ -681,7 +623,7 @@
         The console output lines length should be bigger than the one
         of test_get_console_output.
         """
-        server = self.create_test_server(wait_until='ACTIVE')
+        server = self.client.show_server(self.server_id)['server']
 
         def _check_full_length_console_log():
             output = self.client.get_console_output(server['id'])['output']
@@ -706,15 +648,9 @@
         in SHUTOFF status.
         """
 
-        # NOTE: SHUTOFF is irregular status. To avoid test instability,
-        #       one server is created only for this test without using
-        #       the server that was created in setUpClass.
-        server = self.create_test_server(wait_until='ACTIVE')
-        temp_server_id = server['id']
-
-        self.client.stop_server(temp_server_id)
-        waiters.wait_for_server_status(self.client, temp_server_id, 'SHUTOFF')
-        self.wait_for(self._get_output, temp_server_id)
+        self.client.stop_server(self.server_id)
+        waiters.wait_for_server_status(self.client, self.server_id, 'SHUTOFF')
+        self.wait_for(self._get_output, self.server_id)
 
     @decorators.idempotent_id('77eba8e0-036e-4635-944b-f7a8f3b78dc9')
     @testtools.skipUnless(CONF.compute_feature_enabled.shelve,
@@ -754,11 +690,10 @@
                           'Pause is not available.')
     def test_shelve_paused_server(self):
         """Test shelving a paused server"""
-        server = self.create_test_server(wait_until='ACTIVE')
-        self.client.pause_server(server['id'])
-        waiters.wait_for_server_status(self.client, server['id'], 'PAUSED')
+        self.client.pause_server(self.server_id)
+        waiters.wait_for_server_status(self.client, self.server_id, 'PAUSED')
         # Check if Shelve operation is successful on paused server.
-        compute.shelve_server(self.client, server['id'],
+        compute.shelve_server(self.client, self.server_id,
                               force_shelve_offload=True)
 
     @decorators.idempotent_id('c6bc11bf-592e-4015-9319-1c98dc64daf5')