Comments

You have #Player Class and #Enemy Class as comments. Comments should be used to clarify something that may otherwise be unclear. The line class Player: means that you are creating the Player class, so that comment does nothing.

Spacing

You need a little whitespace. Between the methods in the Player class, for example, I would add a blank line. Between the Player class and the Dragon class, I would add two blank lines. PEP 8, the official style guide for Python, agrees: https://www.python.org/dev/peps/pep-0008/#blank-lines.

Chained or

In a few places, you use if option == ... or option == ... or .... That's longer than it needs to be. You should take advantage of in (See also https://stackoverflow.com/q/15112125/5827958). For example:

if option in {"1", "S", "START"}:
    nameInputAsk()
elif option in {"2", "L", "LOAD"}:
    load()
    nameInputAsk()
...

Global variables

Global variables are evil. Note that global constants are okay, but if you're using the global keyword, it's probably a bad idea. A much better idea is to pass PlayerIG as an argument to whatever function needs it. In addition to avoiding the scourge of global variables, there is also a more clear advantage. You can now use these functions with multiple players.

Naming

According to PEP 8 (https://www.python.org/dev/peps/pep-0008/#function-names):

Function names should be lowercase, with words separated by underscores as necessary to improve readability.

mixedCase is allowed only in contexts where that's already the prevailing style (e.g. threading.py), to retain backwards compatibility.

This is also true of "instance" variables (https://www.python.org/dev/peps/pep-0008/#method-names-and-instance-variables). That means PlayerIG, for example, would also follow this rule and become player_ig.

String formatting

In many places, you use the "old-style" formatting; i.e. %s, %d, etc. There has been a new style of formatting introduced that has actually been around since Python 2.6; i.e. .format(). Since Python 3.0, that is the preferred method (see https://docs.python.org/2/library/stdtypes.html#str.format), though the old style isn't actually deprecated (as pointed out by jpmc26). That means changing something like:

input("Do you want to see your stats %s?" % player_ig.name)

to:

input("Do you want to see your stats {}?".format(player_ig.name))

Even the %d ones don't need any special handling. If you really want, you can use {:d} to make sure it treats it as an integer, but when you are dealing with real integers (not a subclass), it looks the same either way.

Incorrect while loop

In adventuringMarshMount(), you have a while loop that is guaranteed to execute only once, which makes the loop useless. This is because you wrote break at the end of the loop. Whether spinmarshMount is/isn't "marsh"; whether or not it's blank, that loop will break. Come to think of it, it's okay if it executes only once. This isn't user input; it's a random choice, so it's guaranteed to come out with something we're okay with. You can just skip the loop.

The same thing is true of randomDragonAppear(). In that function, however, I have another problem:

true and false as strings

True and False are constants in Python. You might as well use them like that instead of coming up with your own constants. They even work better in the if check:

drag_appear = random.choice([True, False])
if drag_appear:
    print("THERE IS A DRAGON!")
    dragonRunFight()
else:
    print("the noise was only a Pigeon. Pesky things.")

That looks so clean now.

Saving

You have askSave() do the saving for you in addition to asking. What if you decide sometime that you'll save automatically every 5 minutes, say? You have no way of saving except either duplicating code or asking the user anyway. I would put the saving code in its own function, and then call that function from askSave().

Recursion

The default maximum recursion limit is 1000. That means that someone who is trying to crash your program can say something other than one of the correct options 1000 times and you're program will have a nasty error. Maybe you don't care about people who are trying to mess it up, but you might as well keep that from happening. I don't like recursion in most cases. Sometimes it's unfeasable to use a loop, but generally I prefer a loop. For example, askSave() can look like this:

while True:
    ask = input("Do you want to save?\n--> ").upper()
    if ask in {"Y", "YES"}:
        save_game()
    elif ask in {"N", "NO"}:
        print("Okay, maybe next time!")
    else:
        print("Sorry, that does not compute with me! Please try again!")
        continue
    break

while loop is more intuitive than recursion

For example you can re-write:

def userMultiChoice():
    option = input("What do you want to do?\n1] See your blance. \n2] Go to the shop. \n3] Go on an adventure.\n--> ")
    if option == "1" or option == "balance" or option == "Balance" or option == "BALANCE":
        print("Money: %d" % PlayerIG.money)
    elif option == "2" or option == "shop" or option == "Shop" or option == "SHOP" or option == "store" or option == "Store" or option == "STORE":
        pass
    elif option == "3" or option == "adventure" or option == "Adventure" or option == "ADVENTURE" or option == "go" or option == "Go" or option == "GO":
        adventuringMarshMount()
    else:
        print("Sorry, that does not compute with me! Please try again!")
        userMultiChoice()

as

def userMultiChoice():
    option = input("What do you want to do?\n1] See your blance. \n2] Go to the shop. \n3] Go on an adventure.\n--> ")
    while True:
        if option == "1" or option == "balance" or option == "Balance" or option == "BALANCE":
            print("Money: %d" % PlayerIG.money)
            break
        elif option == "2" or option == "shop" or option == "Shop" or option == "SHOP" or option == "store" or option == "Store" or option == "STORE":
            # shop()
            break
        elif option == "3" or option == "adventure" or option == "Adventure" or option == "ADVENTURE" or option == "go" or option == "Go" or option == "GO":
            adventuringMarshMount()
            break
        else:
            print("Sorry, that does not compute with me! Please try again!")
            pass # Repeat loop

Iterative constructs are just more intuitive for the majority of people.

I would change a few things for the readability's sake, in addition to other things (e.g. globals).

While loop vs. recursion
Like other answers pointed out, use while loop over recursion when you can (especially in games, where the idea of a "main game loop" is very grounded). Recursion may be a more "elegant" solution in general, but while loop is definitely the more intuitive in most cases. Also in your case, you're now returning None after None after None... which is not only pointless but also potentially dangerous.

def askSave():
    while True:
        ask = input("Do you want to save?\n--> ").upper()
        if ask == "Y" or ask == "YES":
            Save = Player(PlayerIG.name) #Saves the desired class AND a chosen attribute
            pickle.dump(Save, open("Save File", "wb")) #Creates the file and puts the data into the file
            break # (or return works too)
            #The file doesn't have an extension because it is a binary file and makes it easier to parse. 
        elif ask == "N" or ask == "NO":
            print("Okay, maybe next time!")
            break
        else:
            # Basically, if the input is invalid the infinite loop never stops
            print("Sorry, that does not compute with me! Please try again!")

Comments
Your comments serve little to no purpose! Consider your saving function:

def askSave():
    while True:
        ask = input("Do you want to save?\n--> ").upper()
        if ask == "Y" or ask == "YES":
            Save = Player(PlayerIG.name) #Saves the desired class AND a chosen attribute
            pickle.dump(Save, open("Save File", "wb")) #Creates the file and puts the data into the file
#The file doesn't have an extension because it is a binary file and makes it easier to parse. 

The first may be OK - sometimes you do want to specify what this function with a clear name exactly does. But the second comment is useless - pickle.dump(Save, open()) alone tells you that the line is opening a file, then Saving it through pickling. Comments are good, but don't clutter your code with pointless ones! By the way, the third comment is really good. It should have been in the place of the second comment, because it explains why you're using pickle instead of redundantly describing what pickle does.

Text input options - not comprehensive enough YET not really readable
If you are going to give the players the option of free user input, you must account for a large variety of formats. And writing them all out is, while doable, messy. Here is a solution I'd use.

In a separate file, named responses.py, I would write the following lines:

option_yes = ['y', 'yes', 'yeah', 'yep']
option_no = ['n', 'no', 'nope']

And in the main script, always lower/upper the user input & check if the input is in the options. You actually did the forced-case trick in the askSave function, but a lot of your other functions are missing it.

def askSave():
    while True:
        ask = input("Do you want to save?\n--> ").lower()
        if ask in resp.option_yes:
            Save = Player(PlayerIG.name)
            # The file doesn't have an extension because it is a binary file 
            # and makes it easier to parse. 
            pickle.dump(Save, open("Save File", "wb"))
            break
        elif ask in resp.option_no:
            print("Okay, maybe next time!")
            break 
        else:
            print("Sorry, that does not compute with me! Please try again!")

Globals You used the global keyword exactly twice. While they are fine in a small program like yours, they become increasingly more difficult to maintain and error-prone as your program grows. Unless it is absolutely necessary, always avoid globals like the plague. Now, getting rid of them at this point of production is quite difficult; but since your structure is not very sound (as I have mentioned earlier, don't use recursion), I'll show you how I would change up the first half of the code.

import responses as resp

class Player:
    def __init__(self):
        self.name = None
        self.maxhealth = 100
        self.health = self.maxhealth
        self.attack = 15
        self.money = 0

    def display(self):
        print("Name: {0}\nHealth:{1}/{2}\nAttack Damage:{3}\nMoney:{4}\n".format(self.name, self.health, self.maxhealth, self.damage, self.money))

    def nameInputAsk(self):
        # Don't ask for a new name if the player already has a name
        if self.name: return "stats"

        print("Hello! What do you want your name to be?")
        name = input("--> ")
        print("Oh nice! That's a cool name %s!" % name)
        #time.sleep(2)
        print("Personally I would have gone for something like \'SuperAwesomeBattleFighter\' but I guess that's your loss.")
        self.name = name
        self.nameChangeAsk()

    def nameChangeAsk(self):
        option = input("Do you want to change your name?\n1] Yes\n2] No\n--> ")
        if option in resp.option_yes:
            name = input("Enter your new name:\n--> ")
            print("%s. Yes, that's better; it has a nice ring to it." % name)
            self.name = name
            return "stats"
        elif option in option_no:
            print("Okay. Keep in mind that you won't be able to change your name later!")
            return "stats"
        else:
            print("Sorry, that does not compute with me! Please try again!")
            return "start"

# TODO: Make more enemies!
class Dragon:
    def __init__(self, name):
        self.name = name
        self.maxhealth = 150
        self.health = self.maxhealth
        self.attack = 5

def welcome():
    print("Welcome to The Ultimate Dragon fighter RPG!")
    print("1] Start")
    print("2] Load")
    print("3] Profile")
    print("4] Exit")

    option = input("--> ").upper()
    return option

def main():
    # Initialize the class only once!
    you = Player()

    option = welcome()
    while True:
        if option in resp.option_start:
            option = you.nameInputAsk()      
        elif option in resp.option_load:
            option = load()
        elif option in resp.option_profile:
            option = stats()
        elif option in resp.option_exit:
            print("Goodbye!")
            time.sleep(2)
            break
        else:
            print("Try again!")

This way, there is only one big loop, and the flow of the game is controlled by one local variable option. Having to return option with every function and maintaining it is rather annoying though, and that's why we use frameworks and engines like Pygame, kivy, cocos2d-python, cocos2d-x, Unity, Unreal, etc.

Also, if I were you, I'd write all the messages in one big text file and parse them at game start-up. This way you can get rid of writing long strings directly in your game & make your code look cleaner. This would be done in a very similar manner to how I imported responses.py.