diff --git a/cryptography/hazmat/backends/openssl/backend.py b/cryptography/hazmat/backends/openssl/backend.py
index 99d97b7..afd45e8 100644
--- a/cryptography/hazmat/backends/openssl/backend.py
+++ b/cryptography/hazmat/backends/openssl/backend.py
@@ -58,9 +58,9 @@
 
         self._cipher_registry = {}
         self._register_default_ciphers()
-        self.register_osrandom_engine()
+        self.activate_osrandom_engine()
 
-    def unregister_osrandom_engine(self):
+    def deactivate_osrandom_engine(self):
         e = self._lib.ENGINE_get_default_RAND()
         if e != self._ffi.NULL:
             name = self._lib.ENGINE_get_name(e)
@@ -72,19 +72,19 @@
             res = self._lib.ENGINE_finish(e)
             assert res == 1
 
-    def register_osrandom_engine(self):
+    def activate_osrandom_engine(self):
         current_rand = self._lib.ENGINE_get_default_RAND()
         if current_rand != self._ffi.NULL:
             name = self._lib.ENGINE_get_name(current_rand)
             assert name != self._ffi.NULL
             if name != self._lib.Cryptography_osrandom_engine_name:
-                self._register_osrandom_engine()
+                self._activate_osrandom_engine()
             res = self._lib.ENGINE_finish(current_rand)
             assert res == 1
         else:
-            self._register_osrandom_engine()
+            self._activate_osrandom_engine()
 
-    def _register_osrandom_engine(self):
+    def _activate_osrandom_engine(self):
         e = self._lib.ENGINE_by_id(self._lib.Cryptography_osrandom_engine_id)
         assert e != self._ffi.NULL
         res = self._lib.ENGINE_init(e)
diff --git a/docs/hazmat/backends/openssl.rst b/docs/hazmat/backends/openssl.rst
index 81361f5..1d40b93 100644
--- a/docs/hazmat/backends/openssl.rst
+++ b/docs/hazmat/backends/openssl.rst
@@ -13,14 +13,14 @@
 
         The string name of this backend: ``"openssl"``
 
-    .. method:: register_osrandom_engine()
+    .. method:: activate_osrandom_engine()
 
-        Registers the OS random engine as default. This will effectively
-        disable OpenSSL's default CSPRNG.
+        Activates the OS random engine. This will effectively disable OpenSSL's
+        default CSPRNG.
 
-    .. method:: unregister_osrandom_engine()
+    .. method:: deactivate_osrandom_engine()
 
-        Unregisters the OS random engine if it is default. This will restore
+        Deactivates the OS random engine if it is default. This will restore
         the default OpenSSL CSPRNG. If the OS random engine is not the default
         engine (e.g. if another engine is set as default) nothing will be
         changed.
@@ -45,9 +45,6 @@
 active this engine will be used to generate all the random data OpenSSL
 requests.
 
-If you wish to deactivate the engine you may call
-``unregister_osrandom_engine()`` on the backend object.
-
 When importing only the binding it is added to the engine list but
 **not activated**.
 
diff --git a/tests/hazmat/backends/test_openssl.py b/tests/hazmat/backends/test_openssl.py
index ea71620..daae206 100644
--- a/tests/hazmat/backends/test_openssl.py
+++ b/tests/hazmat/backends/test_openssl.py
@@ -88,7 +88,7 @@
 )
 
 
-def register_dummy_engine():
+def activate_dummy_engine():
     current_rand = backend._lib.ENGINE_get_default_RAND()
     assert current_rand != backend._ffi.NULL
     name = backend._lib.ENGINE_get_name(current_rand)
@@ -110,7 +110,7 @@
     backend._lib.RAND_cleanup()
 
 
-def unregister_dummy_engine():
+def deactivate_dummy_engine():
     e = backend._lib.ENGINE_get_default_RAND()
     if e != backend._ffi.NULL:
         name = backend._lib.ENGINE_get_name(e)
@@ -233,77 +233,77 @@
     def teardown_method(self, method):
         # we need to reset state to being default. backend is a shared global
         # for all these tests.
-        unregister_dummy_engine()
-        backend.register_osrandom_engine()
+        deactivate_dummy_engine()
+        backend.activate_osrandom_engine()
         current_default = backend._lib.ENGINE_get_default_RAND()
         name = backend._lib.ENGINE_get_name(current_default)
         assert name == backend._lib.Cryptography_osrandom_engine_name
 
-    def test_register_osrandom_already_default(self):
+    def test_activate_osrandom_already_default(self):
         e = backend._lib.ENGINE_get_default_RAND()
         name = backend._lib.ENGINE_get_name(e)
         assert name == backend._lib.Cryptography_osrandom_engine_name
         res = backend._lib.ENGINE_free(e)
         assert res == 1
-        backend.register_osrandom_engine()
+        backend.activate_osrandom_engine()
         e = backend._lib.ENGINE_get_default_RAND()
         name = backend._lib.ENGINE_get_name(e)
         assert name == backend._lib.Cryptography_osrandom_engine_name
         res = backend._lib.ENGINE_free(e)
         assert res == 1
 
-    def test_unregister_osrandom_engine_nothing_registered(self):
-        backend.unregister_osrandom_engine()
+    def test_deactivate_osrandom_engine_nothing_registered(self):
+        backend.deactivate_osrandom_engine()
         e = backend._lib.ENGINE_get_default_RAND()
         assert e == backend._ffi.NULL
-        backend.unregister_osrandom_engine()
+        backend.deactivate_osrandom_engine()
         e = backend._lib.ENGINE_get_default_RAND()
         assert e == backend._ffi.NULL
 
-    def test_unregister_osrandom_engine(self):
+    def test_deactivate_osrandom_engine(self):
         e = backend._lib.ENGINE_get_default_RAND()
         assert e != backend._ffi.NULL
         name = backend._lib.ENGINE_get_name(e)
         assert name == backend._lib.Cryptography_osrandom_engine_name
         res = backend._lib.ENGINE_free(e)
         assert res == 1
-        backend.unregister_osrandom_engine()
+        backend.deactivate_osrandom_engine()
         e = backend._lib.ENGINE_get_default_RAND()
         assert e == backend._ffi.NULL
 
-    def test_register_osrandom_no_default(self):
-        backend.unregister_osrandom_engine()
+    def test_activate_osrandom_no_default(self):
+        backend.deactivate_osrandom_engine()
         e = backend._lib.ENGINE_get_default_RAND()
         assert e == backend._ffi.NULL
-        backend.register_osrandom_engine()
+        backend.activate_osrandom_engine()
         e = backend._lib.ENGINE_get_default_RAND()
         name = backend._lib.ENGINE_get_name(e)
         assert name == backend._lib.Cryptography_osrandom_engine_name
         res = backend._lib.ENGINE_free(e)
         assert res == 1
 
-    def test_unregister_osrandom_other_engine_default(self):
-        register_dummy_engine()
+    def test_deactivate_osrandom_other_engine_default(self):
+        activate_dummy_engine()
         default = backend._lib.ENGINE_get_default_RAND()
         default_name = backend._lib.ENGINE_get_name(default)
         assert default_name == dummy_engine.Cryptography_faux_engine_name
         res = backend._lib.ENGINE_finish(default)
         assert res == 1
-        backend.unregister_osrandom_engine()
+        backend.deactivate_osrandom_engine()
         current_default = backend._lib.ENGINE_get_default_RAND()
         name = backend._lib.ENGINE_get_name(current_default)
         assert name == dummy_engine.Cryptography_faux_engine_name
         res = backend._lib.ENGINE_finish(current_default)
         assert res == 1
 
-    def test_register_osrandom_other_engine_default(self):
-        register_dummy_engine()
+    def test_activate_osrandom_other_engine_default(self):
+        activate_dummy_engine()
         default = backend._lib.ENGINE_get_default_RAND()
         default_name = backend._lib.ENGINE_get_name(default)
         assert default_name == dummy_engine.Cryptography_faux_engine_name
         res = backend._lib.ENGINE_finish(default)
         assert res == 1
-        backend.register_osrandom_engine()
+        backend.activate_osrandom_engine()
         current_default = backend._lib.ENGINE_get_default_RAND()
         name = backend._lib.ENGINE_get_name(current_default)
         assert name == backend._lib.Cryptography_osrandom_engine_name