diff --git a/kgb/spies.py b/kgb/spies.py
index d85523d7b5cc82a159376eff33ec65b10936fb59..b1ab5dddb0f32656dff6174b97a946ae70a0cf94 100644
--- a/kgb/spies.py
+++ b/kgb/spies.py
@@ -353,7 +353,6 @@ class FunctionSpy(object):
                         'the bound method.')
 
         if (self.owner is not None and
-            self.func_type == self.TYPE_BOUND_METHOD and
             (not inspect.isclass(self.owner) or
              any(
                 inspect.isclass(parent_cls) and
@@ -366,13 +365,17 @@ class FunctionSpy(object):
             # of the class, or two subclasses of a common class owning the
             # method from conflicting with each other.
             real_func = self._clone_function(real_func)
-            method_type_args = [real_func, self.owner]
 
-            if pyver[0] >= 3:
-                method_type_args.append(self.owner)
+            if self.func_type == self.TYPE_BOUND_METHOD:
+                method_type_args = [real_func, self.owner]
+
+                if pyver[0] >= 3:
+                    method_type_args.append(self.owner)
 
-            self._set_method(self.owner, self.func_name,
-                             types.MethodType(real_func, self.owner))
+                self._set_method(self.owner, self.func_name,
+                                 types.MethodType(real_func, self.owner))
+            else:
+                self._set_method(self.owner, self.func_name, real_func)
 
         self._real_func = real_func
 
diff --git a/kgb/tests/test_function_spy.py b/kgb/tests/test_function_spy.py
index cf36cda8d2942a5030580052ac1771a7751caf91..308106fd2806639fc175651f8e34a940bb3caaf7 100644
--- a/kgb/tests/test_function_spy.py
+++ b/kgb/tests/test_function_spy.py
@@ -52,6 +52,10 @@ class AdderObject(object):
         return i + 1
 
 
+class AdderSubclass(AdderObject):
+    pass
+
+
 class FunctionSpyTests(TestCase):
     """Test cases for kgb.spies.FunctionSpy."""
 
@@ -242,6 +246,39 @@ class FunctionSpyTests(TestCase):
         obj3 = MyParent()
         self.assertFalse(hasattr(obj3.foo, 'spy'))
 
+    def test_construction_with_unbound_method_on_parent(self):
+        """Testing FunctionSpy construction with unbound method from parent of
+        class
+        """
+        obj = AdderSubclass()
+        orig_method = obj.func
+
+        spy = self.agency.spy_on(AdderSubclass.func, owner=AdderSubclass)
+
+        self.assertTrue(hasattr(AdderSubclass.func, 'spy'))
+        self.assertFalse(hasattr(AdderObject.func, 'spy'))
+        self.assertIs(AdderSubclass.func.spy, spy)
+        self.assertEqual(spy.func_name, 'func')
+        self.assertEqual(spy.func_type, spy.TYPE_UNBOUND_METHOD)
+        self.assertEqual(spy.owner, AdderSubclass)
+
+        if isinstance(orig_method, types.FunctionType):
+            # Python 3
+            self.assertIs(AdderSubclass.func, orig_method)
+        elif isinstance(orig_method, types.MethodType):
+            # Python 2
+            self.assertIsNot(AdderSubclass.func, orig_method)
+        else:
+            self.fail('Method has an unexpected type %r' % type(orig_method))
+
+        obj2 = AdderSubclass()
+        self.assertTrue(hasattr(obj2.func, 'spy'))
+        self.assertIs(obj2.func.spy, AdderSubclass.func.spy)
+        self.assertIsInstance(obj2.func, types.MethodType)
+
+        obj3 = AdderObject()
+        self.assertFalse(hasattr(obj3.func, 'spy'))
+
     def test_construction_with_falsy_im_self(self):
         """Testing FunctionSpy construction with a falsy function.im_self"""
         class MyObject(dict):
@@ -1027,6 +1064,26 @@ class FunctionSpyTests(TestCase):
         self.assertEqual(MyObject.foo.__dict__, obj_func_dict)
         self.assertEqual(MyParent.foo.__dict__, parent_func_dict)
 
+    def test_unspy_with_unbound_method_on_parent(self):
+        """Testing FunctionSpy.unspy with unbound method on parent class"""
+        class MyParent(object):
+            def foo(self):
+                pass
+
+        class MyObject(MyParent):
+            pass
+
+        parent_func_dict = MyParent.foo.__dict__.copy()
+        obj_func_dict = MyObject.foo.__dict__.copy()
+
+        spy = self.agency.spy_on(MyObject.foo, owner=MyObject)
+        self.assertNotEqual(MyObject.foo.__dict__, obj_func_dict)
+        self.assertEqual(MyParent.foo.__dict__, parent_func_dict)
+
+        spy.unspy()
+        self.assertEqual(MyObject.foo.__dict__, obj_func_dict)
+        self.assertEqual(MyParent.foo.__dict__, parent_func_dict)
+
     def test_called_with(self):
         """Testing FunctionSpy.called_with"""
         obj = MathClass()