diff --git a/src/Selenium2Library/__init__.py b/src/Selenium2Library/__init__.py
index bd23f053b..4985c258c 100644
--- a/src/Selenium2Library/__init__.py
+++ b/src/Selenium2Library/__init__.py
@@ -1,10 +1,11 @@
-import os
-from keywords import *
-from version import VERSION
-from utils import LibraryListener
+from .keywords import *
+from .utils import LibraryListener
+from .version import VERSION
+
 
 __version__ = VERSION
 
+
 class Selenium2Library(
     _LoggingKeywords,
     _RunOnFailureKeywords,
diff --git a/src/Selenium2Library/keywords/__init__.py b/src/Selenium2Library/keywords/__init__.py
index 431bb107c..ed8b573f6 100644
--- a/src/Selenium2Library/keywords/__init__.py
+++ b/src/Selenium2Library/keywords/__init__.py
@@ -1,15 +1,16 @@
-from _logging import _LoggingKeywords
-from _runonfailure import _RunOnFailureKeywords
-from _browsermanagement import _BrowserManagementKeywords
-from _element import _ElementKeywords
-from _tableelement import _TableElementKeywords
-from _formelement import _FormElementKeywords
-from _selectelement import _SelectElementKeywords
-from _javascript import _JavaScriptKeywords
-from _cookie import _CookieKeywords
-from _screenshot import _ScreenshotKeywords
-from _waiting import _WaitingKeywords
-from _alert import _AlertKeywords
+from ._logging import _LoggingKeywords
+from ._runonfailure import _RunOnFailureKeywords
+from ._browsermanagement import _BrowserManagementKeywords
+from ._element import _ElementKeywords
+from ._tableelement import _TableElementKeywords
+from ._formelement import _FormElementKeywords
+from ._selectelement import _SelectElementKeywords
+from ._javascript import _JavaScriptKeywords
+from ._cookie import _CookieKeywords
+from ._screenshot import _ScreenshotKeywords
+from ._waiting import _WaitingKeywords
+from ._alert import _AlertKeywords
+
 
 __all__ = [
     "_LoggingKeywords",
diff --git a/src/Selenium2Library/keywords/_alert.py b/src/Selenium2Library/keywords/_alert.py
index 07f6faf30..782c5c04f 100644
--- a/src/Selenium2Library/keywords/_alert.py
+++ b/src/Selenium2Library/keywords/_alert.py
@@ -2,7 +2,8 @@
 from selenium.common.exceptions import WebDriverException
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.support import expected_conditions as EC
-from keywordgroup import KeywordGroup
+
+from .keywordgroup import KeywordGroup
 
 
 class _AlertKeywords(KeywordGroup):
diff --git a/src/Selenium2Library/keywords/_browsermanagement.py b/src/Selenium2Library/keywords/_browsermanagement.py
index e3a15ee56..1b2ac380b 100644
--- a/src/Selenium2Library/keywords/_browsermanagement.py
+++ b/src/Selenium2Library/keywords/_browsermanagement.py
@@ -1,12 +1,17 @@
-import os
-import robot
+import os.path
+
 from robot.errors import DataError
+from robot.utils import secs_to_timestr, timestr_to_secs
+
 from selenium import webdriver
+from selenium.common.exceptions import NoSuchWindowException
+
 from Selenium2Library import webdrivermonkeypatches
 from Selenium2Library.utils import BrowserCache
 from Selenium2Library.locators import WindowManager
-from keywordgroup import KeywordGroup
-from selenium.common.exceptions import NoSuchWindowException
+
+from .keywordgroup import KeywordGroup
+
 
 ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 FIREFOX_PROFILE_DIR = os.path.join(ROOT_DIR, 'resources', 'firefoxprofile')
@@ -27,6 +32,7 @@
                  'edge': "_make_edge"
                 }
 
+
 class _BrowserManagementKeywords(KeywordGroup):
 
     def __init__(self):
@@ -428,19 +434,19 @@ def get_selenium_speed(self):
         """Gets the delay in seconds that is waited after each Selenium command.
 
         See `Set Selenium Speed` for an explanation."""
-        return robot.utils.secs_to_timestr(self._speed_in_secs)
+        return secs_to_timestr(self._speed_in_secs)
 
     def get_selenium_timeout(self):
         """Gets the timeout in seconds that is used by various keywords.
 
         See `Set Selenium Timeout` for an explanation."""
-        return robot.utils.secs_to_timestr(self._timeout_in_secs)
+        return secs_to_timestr(self._timeout_in_secs)
 
     def get_selenium_implicit_wait(self):
         """Gets the wait in seconds that is waited by Selenium.
 
         See `Set Selenium Implicit Wait` for an explanation."""
-        return robot.utils.secs_to_timestr(self._implicit_wait_in_secs)
+        return secs_to_timestr(self._implicit_wait_in_secs)
 
     def set_selenium_speed(self, seconds):
         """Sets the delay in seconds that is waited after each Selenium command.
@@ -453,7 +459,7 @@ def set_selenium_speed(self, seconds):
         | Set Selenium Speed | .5 seconds |
         """
         old_speed = self.get_selenium_speed()
-        self._speed_in_secs = robot.utils.timestr_to_secs(seconds)
+        self._speed_in_secs = timestr_to_secs(seconds)
         for browser in self._cache.browsers:
             browser.set_speed(self._speed_in_secs)
         return old_speed
@@ -476,7 +482,7 @@ def set_selenium_timeout(self, seconds):
         | Set Selenium Timeout | ${orig timeout} |
         """
         old_timeout = self.get_selenium_timeout()
-        self._timeout_in_secs = robot.utils.timestr_to_secs(seconds)
+        self._timeout_in_secs = timestr_to_secs(seconds)
         for browser in self._cache.get_open_browsers():
             browser.set_script_timeout(self._timeout_in_secs)
         return old_timeout
@@ -495,7 +501,7 @@ def set_selenium_implicit_wait(self, seconds):
         | Set Selenium Implicit Wait | ${orig wait} |
         """
         old_wait = self.get_selenium_implicit_wait()
-        self._implicit_wait_in_secs = robot.utils.timestr_to_secs(seconds)
+        self._implicit_wait_in_secs = timestr_to_secs(seconds)
         for browser in self._cache.get_open_browsers():
             browser.implicitly_wait(self._implicit_wait_in_secs)
         return old_wait
@@ -513,7 +519,7 @@ def set_browser_implicit_wait(self, seconds):
 
         See also `Set Selenium Implicit Wait`.
         """
-        implicit_wait_in_secs = robot.utils.timestr_to_secs(seconds)
+        implicit_wait_in_secs = timestr_to_secs(seconds)
         self._current_browser().implicitly_wait(implicit_wait_in_secs)
 
     # Private
diff --git a/src/Selenium2Library/keywords/_cookie.py b/src/Selenium2Library/keywords/_cookie.py
index a97808f06..5b2abe011 100644
--- a/src/Selenium2Library/keywords/_cookie.py
+++ b/src/Selenium2Library/keywords/_cookie.py
@@ -1,4 +1,5 @@
-from keywordgroup import KeywordGroup
+from .keywordgroup import KeywordGroup
+
 
 class _CookieKeywords(KeywordGroup):
 
diff --git a/src/Selenium2Library/keywords/_element.py b/src/Selenium2Library/keywords/_element.py
index 357ff1bd5..a5e2fc040 100644
--- a/src/Selenium2Library/keywords/_element.py
+++ b/src/Selenium2Library/keywords/_element.py
@@ -1,18 +1,13 @@
 from selenium.webdriver.common.keys import Keys
 from selenium.webdriver.common.action_chains import ActionChains
 from selenium.webdriver.remote.webelement import WebElement
+
 from Selenium2Library import utils
 from Selenium2Library.locators import ElementFinder
 from Selenium2Library.locators import CustomLocator
-from keywordgroup import KeywordGroup
 
-try:
-    basestring  # attempt to evaluate basestring
-    def isstr(s):
-        return isinstance(s, basestring)
-except NameError:
-    def isstr(s):
-        return isinstance(s, str)
+from .keywordgroup import KeywordGroup
+
 
 class _ElementKeywords(KeywordGroup):
 
@@ -684,7 +679,7 @@ def remove_location_strategy(self, strategy_name):
 
     def _element_find(self, locator, first_only, required, tag=None):
         browser = self._current_browser()
-        if isstr(locator):
+        if isinstance(locator, basestring):
             elements = self._element_finder.find(browser, locator, tag)
             if required and len(elements) == 0:
                 raise ValueError("Element locator '" + locator + "' did not match any elements.")
diff --git a/src/Selenium2Library/keywords/_formelement.py b/src/Selenium2Library/keywords/_formelement.py
index 88a3b50ad..82fc06522 100644
--- a/src/Selenium2Library/keywords/_formelement.py
+++ b/src/Selenium2Library/keywords/_formelement.py
@@ -1,6 +1,7 @@
 import os
-from keywordgroup import KeywordGroup
-from selenium.common.exceptions import WebDriverException
+
+from .keywordgroup import KeywordGroup
+
 
 class _FormElementKeywords(KeywordGroup):
 
diff --git a/src/Selenium2Library/keywords/_javascript.py b/src/Selenium2Library/keywords/_javascript.py
index 8f68025b5..bdf98339b 100644
--- a/src/Selenium2Library/keywords/_javascript.py
+++ b/src/Selenium2Library/keywords/_javascript.py
@@ -1,5 +1,6 @@
 import os
-from keywordgroup import KeywordGroup
+
+from .keywordgroup import KeywordGroup
 
 
 class _JavaScriptKeywords(KeywordGroup):
diff --git a/src/Selenium2Library/keywords/_logging.py b/src/Selenium2Library/keywords/_logging.py
index 4d33d2f7a..5c4a86381 100644
--- a/src/Selenium2Library/keywords/_logging.py
+++ b/src/Selenium2Library/keywords/_logging.py
@@ -1,14 +1,14 @@
 import os
-import sys
+
 from robot.api import logger
-from keywordgroup import KeywordGroup
 from robot.libraries.BuiltIn import BuiltIn
-
 try:
     from robot.libraries.BuiltIn import RobotNotRunningError
-except ImportError:
+except ImportError:  # Support RF < 2.8.5
     RobotNotRunningError = AttributeError
 
+from .keywordgroup import KeywordGroup
+
 
 class _LoggingKeywords(KeywordGroup):
 
diff --git a/src/Selenium2Library/keywords/_runonfailure.py b/src/Selenium2Library/keywords/_runonfailure.py
index 737e02f91..b0d8ecf70 100644
--- a/src/Selenium2Library/keywords/_runonfailure.py
+++ b/src/Selenium2Library/keywords/_runonfailure.py
@@ -1,7 +1,7 @@
-from robot.libraries import BuiltIn
-from keywordgroup import KeywordGroup
+from robot.libraries.BuiltIn import BuiltIn
+
+from .keywordgroup import KeywordGroup
 
-BUILTIN = BuiltIn.BuiltIn()
 
 class _RunOnFailureKeywords(KeywordGroup):
 
@@ -32,9 +32,6 @@ def register_keyword_to_run_on_failure(self, keyword):
         | Register Keyword To Run On Failure  | Log Source | # Run `Log Source` on failure. |
         | ${previous kw}= | Register Keyword To Run On Failure  | Nothing    | # Disables run-on-failure functionality and stores the previous kw name in a variable. |
         | Register Keyword To Run On Failure  | ${previous kw} | # Restore to the previous keyword. |
-
-        This run-on-failure functionality only works when running tests on Python/Jython 2.4
-        or newer and it does not work on IronPython at all.
         """
         old_keyword = self._run_on_failure_keyword
         old_keyword_text = old_keyword if old_keyword is not None else "No keyword"
@@ -56,7 +53,7 @@ def _run_on_failure(self):
             return
         self._running_on_failure_routine = True
         try:
-            BUILTIN.run_keyword(self._run_on_failure_keyword)
+            BuiltIn().run_keyword(self._run_on_failure_keyword)
         except Exception as err:
             self._run_on_failure_error(err)
         finally:
diff --git a/src/Selenium2Library/keywords/_screenshot.py b/src/Selenium2Library/keywords/_screenshot.py
index 8e824ccc8..fd27cd72b 100644
--- a/src/Selenium2Library/keywords/_screenshot.py
+++ b/src/Selenium2Library/keywords/_screenshot.py
@@ -1,8 +1,11 @@
-import robot
-import os, errno
+import errno
+import os
 
-from Selenium2Library import utils
-from keywordgroup import KeywordGroup
+from robot.utils import get_link_path
+
+from Selenium2Library.utils import events
+
+from .keywordgroup import KeywordGroup
 
 
 class _ScreenshotKeywords(KeywordGroup):
@@ -28,9 +31,8 @@ def set_screenshot_directory(self, path, persist=False):
         if persist is False:
             self._screenshot_path_stack.append(self.screenshot_root_directory)
             # Restore after current scope ends
-            utils.events.on('scope_end', 'current',
-                            self._restore_screenshot_directory)
-
+            events.on('scope_end', 'current',
+                      self._restore_screenshot_directory)
         self.screenshot_root_directory = path
 
     def capture_page_screenshot(self,
@@ -130,7 +132,7 @@ def _get_screenshot_paths(self, filename):
         screenshotdir = self._get_screenshot_directory()
         logdir = self._get_log_dir()
         path = os.path.join(screenshotdir, filename)
-        link = robot.utils.get_link_path(path, logdir)
+        link = get_link_path(path, logdir)
         return path, link
 
     def _get_screenshot_index(self, filename):
diff --git a/src/Selenium2Library/keywords/_selectelement.py b/src/Selenium2Library/keywords/_selectelement.py
index a89553d84..4c4e14edf 100644
--- a/src/Selenium2Library/keywords/_selectelement.py
+++ b/src/Selenium2Library/keywords/_selectelement.py
@@ -1,6 +1,7 @@
-from selenium.webdriver.support.ui import Select
-from keywordgroup import KeywordGroup
 from selenium.common.exceptions import NoSuchElementException
+from selenium.webdriver.support.ui import Select
+
+from .keywordgroup import KeywordGroup
 
 
 class _SelectElementKeywords(KeywordGroup):
diff --git a/src/Selenium2Library/keywords/_tableelement.py b/src/Selenium2Library/keywords/_tableelement.py
index 443f9eaa7..0c7b03519 100644
--- a/src/Selenium2Library/keywords/_tableelement.py
+++ b/src/Selenium2Library/keywords/_tableelement.py
@@ -1,7 +1,7 @@
-import os
-import sys
 from Selenium2Library.locators import TableElementFinder
-from keywordgroup import KeywordGroup
+
+from .keywordgroup import KeywordGroup
+
 
 class _TableElementKeywords(KeywordGroup):
 
diff --git a/src/Selenium2Library/keywords/_waiting.py b/src/Selenium2Library/keywords/_waiting.py
index af36bc871..a81226e66 100644
--- a/src/Selenium2Library/keywords/_waiting.py
+++ b/src/Selenium2Library/keywords/_waiting.py
@@ -1,6 +1,9 @@
 import time
-import robot
-from keywordgroup import KeywordGroup
+
+from robot.utils import secs_to_timestr, timestr_to_secs
+
+from .keywordgroup import KeywordGroup
+
 
 class _WaitingKeywords(KeywordGroup):
 
@@ -231,7 +234,7 @@ def wait_func():
         self._wait_until_no_error(timeout, wait_func)
 
     def _wait_until_no_error(self, timeout, wait_func, *args):
-        timeout = robot.utils.timestr_to_secs(timeout) if timeout is not None else self._timeout_in_secs
+        timeout = timestr_to_secs(timeout) if timeout is not None else self._timeout_in_secs
         maxtime = time.time() + timeout
         while True:
             timeout_error = wait_func(*args)
@@ -241,5 +244,5 @@ def _wait_until_no_error(self, timeout, wait_func, *args):
             time.sleep(0.2)
 
     def _format_timeout(self, timeout):
-        timeout = robot.utils.timestr_to_secs(timeout) if timeout is not None else self._timeout_in_secs
-        return robot.utils.secs_to_timestr(timeout)
+        timeout = timestr_to_secs(timeout) if timeout is not None else self._timeout_in_secs
+        return secs_to_timestr(timeout)
diff --git a/src/Selenium2Library/keywords/keywordgroup.py b/src/Selenium2Library/keywords/keywordgroup.py
index dab2af51d..47b43486f 100644
--- a/src/Selenium2Library/keywords/keywordgroup.py
+++ b/src/Selenium2Library/keywords/keywordgroup.py
@@ -1,11 +1,8 @@
 import sys
 import inspect
-try:
-    from decorator import decorator
-except SyntaxError: # decorator module requires Python/Jython 2.4+
-    decorator = None
-if sys.platform == 'cli':
-    decorator = None # decorator module doesn't work with IronPython 2.6
+
+from decorator import decorator
+
 
 def _run_on_failure_decorator(method, *args, **kwargs):
     self = args[0]
@@ -25,7 +22,9 @@ def _run_on_failure_decorator(method, *args, **kwargs):
             self._already_in_keyword = False
             self._has_run_on_failure = False
 
+
 class KeywordGroupMetaClass(type):
+
     def __new__(cls, clsname, bases, dict):
         if decorator:
             for name, method in list(dict.items()):
@@ -33,5 +32,6 @@ def __new__(cls, clsname, bases, dict):
                     dict[name] = decorator(_run_on_failure_decorator, method)
         return type.__new__(cls, clsname, bases, dict)
 
+
 class KeywordGroup(object):
     __metaclass__ = KeywordGroupMetaClass
diff --git a/src/Selenium2Library/locators/__init__.py b/src/Selenium2Library/locators/__init__.py
index 99bf42307..355641d68 100644
--- a/src/Selenium2Library/locators/__init__.py
+++ b/src/Selenium2Library/locators/__init__.py
@@ -1,7 +1,8 @@
-from elementfinder import ElementFinder
-from tableelementfinder import TableElementFinder
-from windowmanager import WindowManager
-from customlocator import CustomLocator
+from .elementfinder import ElementFinder
+from .customlocator import CustomLocator
+from .tableelementfinder import TableElementFinder
+from .windowmanager import WindowManager
+
 
 __all__ = [
     "ElementFinder",
diff --git a/src/Selenium2Library/locators/customlocator.py b/src/Selenium2Library/locators/customlocator.py
index c7f091c39..6f68752d7 100644
--- a/src/Selenium2Library/locators/customlocator.py
+++ b/src/Selenium2Library/locators/customlocator.py
@@ -1,9 +1,5 @@
 from robot.libraries.BuiltIn import BuiltIn
 
-try:
-    string_type = basestring
-except NameError:
-    string_type = str
 
 class CustomLocator(object):
 
@@ -12,9 +8,8 @@ def __init__(self, name, finder):
         self.finder = finder
 
     def find(self, *args):
-
         # Allow custom locators to be keywords or normal methods
-        if isinstance(self.finder, string_type):
+        if isinstance(self.finder, basestring):
             element = BuiltIn().run_keyword(self.finder, *args)
         elif hasattr(self.finder, '__call__'):
             element = self.finder(*args)
@@ -22,7 +17,7 @@ def find(self, *args):
             raise AttributeError('Invalid type provided for Custom Locator %s' % self.name)
 
         # Always return an array
-        if hasattr(element, '__len__') and (not isinstance(element, string_type)):
+        if hasattr(element, '__len__') and (not isinstance(element, basestring)):
             return element
         else:
             return [element]
diff --git a/src/Selenium2Library/locators/elementfinder.py b/src/Selenium2Library/locators/elementfinder.py
index 6bc0496e9..1b54fa1ed 100644
--- a/src/Selenium2Library/locators/elementfinder.py
+++ b/src/Selenium2Library/locators/elementfinder.py
@@ -1,7 +1,8 @@
-from Selenium2Library import utils
 from robot.api import logger
 from robot.utils import NormalizedDict
 
+from Selenium2Library.utils import escape_xpath_value, events
+
 
 class ElementFinder(object):
 
@@ -45,7 +46,7 @@ def register(self, strategy, persist):
 
         if not persist:
             # Unregister after current scope ends
-            utils.events.on('scope_end', 'current', self.unregister, strategy.name)
+            events.on('scope_end', 'current', self.unregister, strategy.name)
 
     def unregister(self, strategy_name):
         if strategy_name in self._default_strategies:
@@ -133,7 +134,7 @@ def _find_by_key_attrs(self, browser, criteria, tag, constraints):
         if tag is not None:
             key_attrs = self._key_attrs.get(tag, key_attrs)
 
-        xpath_criteria = utils.escape_xpath_value(criteria)
+        xpath_criteria = escape_xpath_value(criteria)
         xpath_tag = tag if tag is not None else '*'
         xpath_constraints = ["@%s='%s'" % (name, constraints[name]) for name in constraints]
         xpath_searchers = ["%s=%s" % (attr, xpath_criteria) for attr in key_attrs]
@@ -206,7 +207,7 @@ def _get_attrs_with_url(self, key_attrs, criteria, browser):
             if attr in key_attrs:
                 if url is None or xpath_url is None:
                     url = self._get_base_url(browser) + "/" + criteria
-                    xpath_url = utils.escape_xpath_value(url)
+                    xpath_url = escape_xpath_value(url)
                 attrs.append("%s=%s" % (attr, xpath_url))
         return attrs
 
@@ -224,7 +225,7 @@ def _parse_locator(self, locator):
             if len(locator_parts[1]) > 0:
                 prefix = locator_parts[0]
                 criteria = locator_parts[2].strip()
-        return (prefix, criteria)
+        return prefix, criteria
 
     def _normalize_result(self, elements):
         if not isinstance(elements, list):
diff --git a/src/Selenium2Library/locators/tableelementfinder.py b/src/Selenium2Library/locators/tableelementfinder.py
index 91c4b97c9..7567718df 100644
--- a/src/Selenium2Library/locators/tableelementfinder.py
+++ b/src/Selenium2Library/locators/tableelementfinder.py
@@ -1,6 +1,5 @@
-from selenium.common.exceptions import NoSuchElementException
-from Selenium2Library import utils
-from elementfinder import ElementFinder
+from .elementfinder import ElementFinder
+
 
 class TableElementFinder(object):
 
diff --git a/src/Selenium2Library/locators/windowmanager.py b/src/Selenium2Library/locators/windowmanager.py
index f7ba1ccf0..f47cb9d58 100644
--- a/src/Selenium2Library/locators/windowmanager.py
+++ b/src/Selenium2Library/locators/windowmanager.py
@@ -1,8 +1,6 @@
-from types import *
-from robot import utils
-from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.common.exceptions import NoSuchWindowException
 
+
 class WindowManager(object):
 
     def __init__(self):
diff --git a/src/Selenium2Library/utils/__init__.py b/src/Selenium2Library/utils/__init__.py
index ec116c39d..f43c24c57 100644
--- a/src/Selenium2Library/utils/__init__.py
+++ b/src/Selenium2Library/utils/__init__.py
@@ -1,6 +1,6 @@
-from browsercache import BrowserCache
-from librarylistener import LibraryListener
-import events
+from . import events
+from .browsercache import BrowserCache
+from .librarylistener import LibraryListener
 
 
 def escape_xpath_value(value):
diff --git a/src/Selenium2Library/utils/browsercache.py b/src/Selenium2Library/utils/browsercache.py
index 32590f4a6..14667000b 100644
--- a/src/Selenium2Library/utils/browsercache.py
+++ b/src/Selenium2Library/utils/browsercache.py
@@ -1,5 +1,6 @@
 from robot.utils import ConnectionCache
 
+
 class BrowserCache(ConnectionCache):
 
     def __init__(self):
diff --git a/src/Selenium2Library/utils/events/__init__.py b/src/Selenium2Library/utils/events/__init__.py
index 58da7a7b5..adeb18281 100644
--- a/src/Selenium2Library/utils/events/__init__.py
+++ b/src/Selenium2Library/utils/events/__init__.py
@@ -1,7 +1,5 @@
-from scope_event import ScopeStart, ScopeEnd
+from .scope_event import ScopeStart, ScopeEnd
 
-_registered_events = [ ScopeStart, ScopeEnd ]
-_events = []
 
 __all__ = [
     "on",
@@ -9,17 +7,23 @@
     "register_event"
 ]
 
+_registered_events = [ScopeStart, ScopeEnd]
+_events = []
+
+
 def on(event_name, *args, **kwargs):
     for event in _registered_events:
         if event.name == event_name:
             _events.append(event(*args, **kwargs))
             return
 
+
 def dispatch(event_name, *args, **kwargs):
     for event in _events:
         if event.name == event_name:
             event.trigger(*args, **kwargs)
 
+
 def register_event(event):
     for registered_event in _registered_events:
         if event.name == registered_event.name:
diff --git a/src/Selenium2Library/utils/events/event.py b/src/Selenium2Library/utils/events/event.py
index 17e42aabd..91b2baaf4 100644
--- a/src/Selenium2Library/utils/events/event.py
+++ b/src/Selenium2Library/utils/events/event.py
@@ -1,5 +1,6 @@
 import abc
 
+
 class Event(object):
 
     @abc.abstractmethod
diff --git a/src/Selenium2Library/utils/events/scope_event.py b/src/Selenium2Library/utils/events/scope_event.py
index 5e2913221..3746d0c40 100644
--- a/src/Selenium2Library/utils/events/scope_event.py
+++ b/src/Selenium2Library/utils/events/scope_event.py
@@ -1,7 +1,10 @@
-from event import Event
 from robot.libraries.BuiltIn import BuiltIn
 
+from .event import Event
+
+
 class ScopeEvent(Event):
+
     def __init__(self, scope, action, *args, **kwargs):
         self.scope = scope
         self.action = action
@@ -17,8 +20,10 @@ def trigger(self, *args, **kwargs):
         if args[0] == self.scope:
             self.action(*self.action_args, **self.action_kwargs)
 
+
 class ScopeStart(ScopeEvent):
     name = 'scope_start'
 
+
 class ScopeEnd(ScopeEvent):
     name = 'scope_end'
diff --git a/src/Selenium2Library/utils/librarylistener.py b/src/Selenium2Library/utils/librarylistener.py
index cb046145f..01cd278ef 100644
--- a/src/Selenium2Library/utils/librarylistener.py
+++ b/src/Selenium2Library/utils/librarylistener.py
@@ -1,18 +1,17 @@
-import events as event
-from robot.api import logger
+from .events import dispatch
 
-class LibraryListener(object):
 
+class LibraryListener(object):
     ROBOT_LISTENER_API_VERSION = 2
 
     def start_suite(self, name, attrs):
-        event.dispatch( 'scope_start', attrs['longname'] )
+        dispatch('scope_start', attrs['longname'])
 
     def end_suite(self, name, attrs):
-        event.dispatch( 'scope_end', attrs['longname'] )
+        dispatch('scope_end', attrs['longname'])
 
     def start_test(self, name, attrs):
-        event.dispatch( 'scope_start', attrs['longname'] )
+        dispatch('scope_start', attrs['longname'])
 
     def end_test(self, name, attrs):
-        event.dispatch( 'scope_end', attrs['longname'] )
+        dispatch('scope_end', attrs['longname'])
diff --git a/src/Selenium2Library/webdrivermonkeypatches.py b/src/Selenium2Library/webdrivermonkeypatches.py
index 53d7e7de5..1ec0a07ee 100644
--- a/src/Selenium2Library/webdrivermonkeypatches.py
+++ b/src/Selenium2Library/webdrivermonkeypatches.py
@@ -1,7 +1,7 @@
 import time
-from robot import utils
+
 from selenium.webdriver.remote.webdriver import WebDriver as RemoteWebDriver
-from locators import WindowManager
+
 
 class WebDriverMonkeyPatches:
 
diff --git a/test/run_tests.py b/test/run_tests.py
index 4de5cf7d7..badc6e42f 100755
--- a/test/run_tests.py
+++ b/test/run_tests.py
@@ -1,13 +1,16 @@
 #!/usr/bin/env python
+
 from __future__ import print_function
-import env
+
 import os
 import sys
 from subprocess import Popen, call
 from tempfile import TemporaryFile
 
+import env
 from run_unit_tests import run_unit_tests
 
+
 ROBOT_ARGS = [
     '--doc', 'SeleniumSPacceptanceSPtestsSPwithSP%(browser)s',
     '--outputdir', '%(outdir)s',
@@ -31,7 +34,9 @@
     '--noncritical', 'known_issue_-_%(pyVersion)s',
     '--noncritical', 'known_issue_-_%(browser)s',
 ]
-ARG_VALUES = {'outdir': env.RESULTS_DIR, 'pythonpath': ':'.join((env.SRC_DIR, env.TEST_LIBS_DIR))}
+ARG_VALUES = {'outdir': env.RESULTS_DIR,
+              'pythonpath': ':'.join((env.SRC_DIR, env.TEST_LIBS_DIR))}
+
 
 def acceptance_tests(interpreter, browser, args):
     ARG_VALUES['browser'] = browser.replace('*', '')
@@ -44,11 +49,13 @@ def acceptance_tests(interpreter, browser, args):
     stop_http_server()
     return process_output(args)
 
+
 def start_http_server():
     server_output = TemporaryFile()
-    Popen(['python', env.HTTP_SERVER_FILE ,'start'],
+    Popen(['python', env.HTTP_SERVER_FILE, 'start'],
           stdout=server_output, stderr=server_output)
 
+
 def execute_tests(runner, args):
     if not os.path.exists(env.RESULTS_DIR):
         os.mkdir(env.RESULTS_DIR)
@@ -58,14 +65,15 @@ def execute_tests(runner, args):
     syslog = os.path.join(env.RESULTS_DIR, 'syslog.txt')
     call(command, shell=os.sep=='\\', env=dict(os.environ, ROBOT_SYSLOG_FILE=syslog))
 
+
 def stop_http_server():
     call(['python', env.HTTP_SERVER_FILE, 'stop'])
 
+
 def process_output(args):
     print()
-    if _has_robot_27():
-        call(['python', os.path.join(env.RESOURCES_DIR, 'statuschecker.py'),
-             os.path.join(env.RESULTS_DIR, 'output.xml')])
+    call(['python', os.path.join(env.RESOURCES_DIR, 'statuschecker.py'),
+         os.path.join(env.RESULTS_DIR, 'output.xml')])
     rebot = 'rebot' if os.sep == '/' else 'rebot.bat'
     rebot_cmd = [rebot] + [ arg % ARG_VALUES for arg in REBOT_ARGS ] + args + \
                 [os.path.join(ARG_VALUES['outdir'], 'output.xml') ]
@@ -78,21 +86,13 @@ def process_output(args):
         print('%d critical test%s failed' % (rc, 's' if rc != 1 else ''))
     return rc
 
-def _has_robot_27():
-    try:
-        from robot.result import ExecutionResult
-    except:
-        return False
-    return True
-
-def _exit(rc):
-    sys.exit(rc)
 
 def _help():
     print('Usage:  python run_tests.py python|jython browser [options]')
     print()
     print('See README.txt for details.')
-    return 255
+    sys.exit(255)
+
 
 def _run_unit_tests():
     print('Running unit tests')
@@ -104,14 +104,15 @@ def _run_unit_tests():
     return failures
 
 
-if __name__ ==  '__main__':
+if __name__ == '__main__':
     if not len(sys.argv) > 2:
-        _exit(_help())
+        _help()
     unit_failures = _run_unit_tests()
     if unit_failures:
-        _exit(unit_failures)
+        sys.exit(unit_failures)
     interpreter = sys.argv[1]
     browser = sys.argv[2].lower()
     args = sys.argv[3:]
     if browser != 'unit':
-        _exit(acceptance_tests(interpreter, browser, args))
+        rc = acceptance_tests(interpreter, browser, args)
+        sys.exit(rc)
diff --git a/test/unit/keywords/test_browsermanagement.py b/test/unit/keywords/test_browsermanagement.py
index 782491730..d485fb51a 100644
--- a/test/unit/keywords/test_browsermanagement.py
+++ b/test/unit/keywords/test_browsermanagement.py
@@ -1,7 +1,10 @@
 import unittest
-from Selenium2Library.keywords._browsermanagement import _BrowserManagementKeywords
+
+from mockito import mock, verify, verifyNoMoreInteractions
 from selenium import webdriver
-from mockito import *
+
+from Selenium2Library.keywords._browsermanagement import _BrowserManagementKeywords
+
 
 class BrowserManagementTests(unittest.TestCase): 
 
diff --git a/test/unit/locators/test_elementfinder.py b/test/unit/locators/test_elementfinder.py
index fba91e30e..4c1c07d2e 100644
--- a/test/unit/locators/test_elementfinder.py
+++ b/test/unit/locators/test_elementfinder.py
@@ -1,9 +1,11 @@
 import unittest
-import os
-from Selenium2Library.locators import ElementFinder
-from mockito import *
+
+from mockito import any, mock, verify, when
 from robot.utils.asserts import assert_raises_with_msg
 
+from Selenium2Library.locators import ElementFinder
+
+
 class ElementFinderTests(unittest.TestCase):
 
     def test_find_with_invalid_prefix(self):
diff --git a/test/unit/locators/test_tableelementfinder.py b/test/unit/locators/test_tableelementfinder.py
index 649c49fdf..9df0f824d 100644
--- a/test/unit/locators/test_tableelementfinder.py
+++ b/test/unit/locators/test_tableelementfinder.py
@@ -1,6 +1,9 @@
 import unittest
+
+from mockito import mock, verify, when
+
 from Selenium2Library.locators import TableElementFinder
-from mockito import *
+
 
 class ElementFinderTests(unittest.TestCase):
 
diff --git a/test/unit/locators/test_windowmanager.py b/test/unit/locators/test_windowmanager.py
index 7858343a2..a2b4c039d 100644
--- a/test/unit/locators/test_windowmanager.py
+++ b/test/unit/locators/test_windowmanager.py
@@ -1,10 +1,12 @@
 import unittest
-import os
-from Selenium2Library.locators import WindowManager
-from mockito import *
 import uuid
+
+from mockito import mock
+
+from Selenium2Library.locators import WindowManager
 from selenium.common.exceptions import NoSuchWindowException
 
+
 class WindowManagerTests(unittest.TestCase):
 
     def test_select_with_invalid_prefix(self):
@@ -220,11 +222,7 @@ def test_select_by_default_no_match(self):
             { 'name': 'win1', 'title': "Title 1", 'url': 'http://localhost/page1.html' },
             { 'name': 'win2', 'title': "Title 2", 'url': 'http://localhost/page2.html' },
             { 'name': 'win3', 'title': "Title 3", 'url': 'http://localhost/page3.html' })
-
-        try:
-            self.assertRaises(ValueError, manager.select, browser, "win-1")
-        except ValueError as e:
-            self.assertEqual(context.exception.message, "Unable to locate window with name or title 'win-1'")
+        self.assertRaises(ValueError, manager.select, browser, "win-1")
 
     def test_select_with_sloppy_prefix(self):
         manager = WindowManager()
diff --git a/test/unit/test_webdrivermonkeypatches.py b/test/unit/test_webdrivermonkeypatches.py
index 1162be0c0..fc444b65a 100644
--- a/test/unit/test_webdrivermonkeypatches.py
+++ b/test/unit/test_webdrivermonkeypatches.py
@@ -1,7 +1,10 @@
 import unittest
+
+from mockito import when
+
 from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.remote.webdriver import WebDriver as RemoteWebDriver
-from mockito import *
+
 
 SCRIPT = "return [ window.id, window.name, document.title, document.URL ];"
 HANDLE = "17c3dc18-0443-478b-aec6-ed7e2a5da7e1"
diff --git a/test/unit/utils/test_browsercache.py b/test/unit/utils/test_browsercache.py
index 50abcbd7b..1ff596fb1 100644
--- a/test/unit/utils/test_browsercache.py
+++ b/test/unit/utils/test_browsercache.py
@@ -1,7 +1,9 @@
 import unittest
-import os
+
+from mockito import mock, verify
+
 from Selenium2Library.utils import BrowserCache
-from mockito import *
+
 
 class BrowserCacheTests(unittest.TestCase): 
 
diff --git a/test/unit/utils/test_package.py b/test/unit/utils/test_package.py
index f3c10e5aa..5f7cc26a7 100644
--- a/test/unit/utils/test_package.py
+++ b/test/unit/utils/test_package.py
@@ -1,19 +1,18 @@
 import unittest
-from Selenium2Library import utils
+
+from Selenium2Library.utils import escape_xpath_value
+
 
 class UtilsPackageTests(unittest.TestCase):
 
     def test_escape_xpath_value_with_apos(self):
-        self.assertEqual(
-            utils.escape_xpath_value("test '1'"),
-            "\"test '1'\"")
+        self.assertEqual(escape_xpath_value("test '1'"),
+                         "\"test '1'\"")
 
     def test_escape_xpath_value_with_quote(self):
-        self.assertEqual(
-            utils.escape_xpath_value("test \"1\""),
-            "'test \"1\"'")
+        self.assertEqual(escape_xpath_value("test \"1\""),
+                         "'test \"1\"'")
 
     def test_escape_xpath_value_with_quote_and_apos(self):
-        self.assertEqual(
-            utils.escape_xpath_value("test \"1\" and '2'"),
-            "concat('test \"1\" and ', \"'\", '2', \"'\", '')")
+        self.assertEqual(escape_xpath_value("test \"1\" and '2'"),
+                         "concat('test \"1\" and ', \"'\", '2', \"'\", '')")