Median,

First of all, Protege does not show by default all the inferences that you may be interested in seeing, but you can easily activate different inference types through the Reasoner->Configure... menu (in your case you want to check the "Domains" and "Ranges" checkboxes under the "Displayed Object Property Inferences" section).

Second, although I am not a logics expert I think, that the answer to your first and second question is in fact "No", that is why I believe Protege does not show them, even if you activate the domain and range inferences in the configuration. Here is my reasoning, in case of your first question:

Although you correctly infer that 

whatever x is, if hasCar(x, y) => driver (x) => human(x),

x will still belong to the subset of those members of the human class that are also members of the driver class (i.e. they will never be member of the complement of the driver class, such as the non-driver humans - which BTW, I think is a inappropriate modeling in your example, since we know that non-driver persons can own a car in reality), and as such the the domain of the hasCar property will remain the driver class and cannot be extended to the entire human class. If you would say, for the sake of the argument, that there is no human that cannot drive (i.e. the human class is equivalent  with the driver class), than protege would show that the domain of the hasCar property is not just driver but also human.

Same reasoning goes for the range in your second question.

The answer to your third question is "True", but possibly not for the reasons that you would think of. The key statement that produce that inference are the range/domain statements, not the subclass relationship between audiCar and car. 

You may wonder why this inferable statement is not shown in Protege, even if you check all the possible reasoner configuration options. Simply, because there are infinite number of statements that can be entailed from an ontology, and Protege shows only a certain subset of those, which are commonly of interest to people who are building or using an ontology.  And this particular type of inference did not fall in that category.

However, if you write this statement into the DL Query plugin, and you check the "Equivalent classes" checkbox, you will see that driver class is returned as an equivalent class to the "driver hasAudiCar min 1 car" expression, and you can even get a nice explanation of why this is the case, if you click on the question mark on the right of the driver class in the query results.

I hope this helps.

@Median, @Csongor. Actually I think Median is right in question 1 and that hasCar Domain Human is a correct inference. It is just not a very useful inference. The reason is that unlike mathematical functions, OWL properties are "partially defined" relations. Thus the statement that hasCar Domain Humans  is no statement that all Humans have a car, merely that stating that if there is an assertion x hasCar y then x is human. Likewise in question 2 for ranges (which are just the domains of the inverseproperyOf).

In question 3 something weird is going on though, and I am surprised that  any form of Description logic gives you an answer. However I may just misunderstand, so let me write what I think you want to say  painstakingly in Turtle (well at least as far as I remember namespace and capitalization, which may need some tweaking, and substituting AudiDriver for Driver)

(1) :hasAudiCar rdf:domain :AudiDriver. 
(2) :hasAudiCar rdf:range :AudiCar.
(3) :AudiDriver  rdfs:subclassOf  [a owl:Restriction;
                                                 owl:onProperty :hasAudiCar;
                                                 owl:minCardinality 1;
 owl:toClass :AudiCar].

(4) :AudiCar rdfs:subClassOf :Car.

from which you want to conclude

:AudiDriver rdfs:subClassOf [a owl:Restriction;
                                                 owl:onProperty :hasAudiCar;
                                                 owl:minCardinality 1;
 owl:toClass :Car]

which is of course true.

What I think you have actually written (again substituting AudiDriver for Driver) is

(1) :hasAudiCar rdf:domain :AudiDriver. 
(2) :hasAudiCar rdf:range :AudiCar.
(3) :AudiDriver  :hasAudiCar  [a owl:Restriction;
                                                 owl:onProperty :hasAudiCar;
                                                 owl:minCardinality 1;

owl:toClass :AudiCar].

(4) :AudiCar rdfs:subClassOf :Car.

You want to conclude that:

(5) :AudiDriver :hasAudiCar [a owl:Restriction;
                                           owl:onProperty :hasAudiCar;
                                            owl:minCardinality 1;

owl:toClass :Car]

Now that is also (sort of) true since because of (2)

[a owl:Restriction;
    owl:onProperty :hasAudiCar;
    owl:minCardinality 1;

owl:toClass :AudiCar] owl:sameClass [a owl:Restriction;
    owl:onProperty :hasAudiCar;
    owl:minCardinality 1]

and

[a owl:Restriction;
    owl:onProperty :hasAudiCar;
    owl:minCardinality 1;

owl:toClass :Car] owl:sameClass [a owl:Restriction;
    owl:onProperty :hasAudiCar;
    owl:minCardinality 1]

HOWEVER in writing (2) and (5) you completely violate the distinction between instances and classes which is forbidden in the stricter levels of description logic and in OWL (but not in RDF). For example you would now conclude that

[a owl:Restriction;
    owl:onProperty :hasAudiCar;
    owl:minCardinality 1] a :Audicar,

in other words the class of things that has an AudiCar is an instance of an AudiCar. Surely not what you meant. But again I may just misunderstand your notation and 

@Rogier Brussee , @Csongor Nyulas , thank you so much for your responses.

Well, first I think that I just missed something in (3) in my last inference, which is the subclassOf expression. However, I didn't get your point about mixing between instances and schema. @Rogier Brussee, The AudiDriver class is a subclass of the restriction you provide in the end of your answer, nothing wrong, I think. Anyway, as you state the fashion I conclude is correct, however, not useful. i.e. domains and ranges are inherited in a way that seems not clear as parent is a domain for its son domain properties. In addition, and in a another direction, sons inherits parents declared properties and their restrictions if any, i.e. if we have:

(A) Audi4X4Driver subClassOf AudiDriver

then, we can conclude that

(B) Audi4X4Driver subClassOf hasAudiCar min 1 AudiCar.

Thus, this two direction inference (from son to parent in domain and range and in the other way for declared properties restrictions) seems a little ambiguous, however, it's true.

The second issue to say, I realized that showing vs. non-showing these inferences depends on the tool options, not their correctness as they are true. So, in Protgere 4, it shows the domain and range inferences I provided in my question unlike Protege 5. However, and for some reason that I don't know, in the environment I'm working in (Jena + Pellet), these inferences are not considered, maybe because as @Csongor Nyulas suggests that a lot of useless inferences may complicate the GUI with no use. Now, my solution is extending the way Pellet behaves with Jena to meet my needs.

Thank you again :-)

The point I make about instances vs. Classes is that it is forbidden to make a statement like

x hasAudiCar  y

on a owl:class x, because you are now mixing up classes and instances which gets you into all sorts of nastyness. It is also definitely not what you mean. If you want to say that hasAudiCar is relation between Drivers  and AudiCar s and that AudiDriver s can be characterised as being the ones that have at least one AudiCar, then you say

:hasAudiCar a owl:ObjectProperty;

                    rdf:domain :Driver;

                    rdf:range :AudiCar.

:AudiDrive owl:intersection (:Driver

                                          [ a owl:Restriction;

                                               owl:onProperty :hasAudiCar;

                                               owl:minCardinality 1]). 

to which you might want to add

:AudiCar rdfs:subClassOf :Car.

or even 

:hasCar a owl:ObjectPropery;

            rdfs:domain Driver;

            rdfs:range :Car.

:hasAudiCar 'rdfs:subPropery :hasCar.

@Rogier Brussee , I totally agree. But I'm afraid I cannot capture where I mixed up instances with classes can you refer me please? maybe you misunderstood my notation somewhere, I'm totally talking about classes :-)

Thanks again.

Your statement (3) which I read as  statement number (3) in my first post.