
<p class="has-drop-cap">Australienskan <strong>Kerryn Manning</strong> är i en klass för sig och hon har hittills vunnit 4.221 lopp under sin karriär och ståtar med starka 23 i segerprocent på 18.671 starter.</p>



<p>Den 47-åriga australienskan kan dessutom räkna in 39 Grupp I-vinster plus att hon vann Harley Davidson Race med <strong>Knight Pistol </strong>på Sörlandet 1997 före norske storstjärnan Gentle Star. När Manning vann det loppet var hon bara 21 år gammal och det var hennes 100:e seger.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/imago0020194243h1001920x1080-617x347.jpg" alt="" class="wp-image-558881"/><figcaption class="wp-element-caption">Rita Drees är den kvinnliga amatörkusk som vunnit flest lopp. Foto: Marius Schwarz</figcaption></figure>



<p>Enligt vad Sulkysport erfar finns det ytterligare tre kvinnor som vunnit över 1.000 lopp. Tyska amatörkuskarna <strong>Rita Drees </strong>och <strong>Marion Jauss </strong>vann 2.432 respektive 1.614 lopp. Rita Drees körde sitt sista lopp 2020 och då var hon 78 år gammal. Hennes karriär omfattade hela 55 år!</p>



<p>– Jag tog min amatörlicens 1965 och på den tiden tävlade män och kvinnor var för sig. Och vi damer var faktiskt glada om vi hade en tävling en gång i månaden. Idag är det naturligtvis helt annorlunda, har Rita Drees sagt i en intervju med <a href="https://www.deutschlandfunkkultur.de/rita-drees-leben-fuer-den-trabrennsport-100.html" data-type="link" data-id="https://www.deutschlandfunkkultur.de/rita-drees-leben-fuer-den-trabrennsport-100.html" target="_blank" rel="noreferrer noopener">Deutschlandfunk Kultur.</a></p>



<h2 class="wp-block-heading">Segerrikaste kvinnor i världen</h2>



<p>Namn – Land – Segrar</p>



<ol class="wp-block-list">
<li><strong>Kerryn Manning </strong>– Australien – 4.221</li>



<li><strong>Rita Drees </strong>– Tyskland – 2.432</li>



<li><strong>Bea Farber </strong>– USA – 1.801</li>



<li><strong>Marion Jauss</strong> – Tyskland – 1.614</li>
</ol>



<h2 class="wp-block-heading">Började tävla mot varandra</h2>



<p>13 år senare – året var 1978 – började män och kvinnor att tävla mot varandra i Tyskland och det hindrade inte Drees framfart. Vid 14 tillfällen tog Rita hem championatet för amatörer. Hon vann också dubbla titlar i EM för damer.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2020/05/skarmavbild20200504kl.19.23.23-350x291.png" alt="" class="wp-image-87429"/><figcaption class="wp-element-caption">Marion Jauss. Foto: Hall of Fame, Tyskland</figcaption></figure>



<p><a rel="noreferrer noopener" href="https://sulkysport.se/marion-jauss-dod/" data-type="link" data-id="https://sulkysport.se/marion-jauss-dod/" target="_blank">Marion Jauss</a>, som gick ur tiden 2020, blev amatörchampion vid fem tillfällen i Tyskland efter ha börjat köra lopp 1975. Hon var dessutom en framstående hästägare och sponsrade travsporten i Tyskland med stora summor.</p>



<h2 class="wp-block-heading">Först till 1.000 segrar</h2>



<p>På andra sidan Atlanten toppar <strong>Bea ”Queen Bea” Farber </strong>med 1.801 triumfer och hon var den första kvinnan i världen till 1.000 segrar. </p>



<p>Hon bröt många normer i den mansdominerade amerikanska travsporten när hon valde en karriär i sulkyn istället för ”hemarbete”. Tillfällena var inte precis få när hon fick försvara sitt yrkesval och hon hade ofta svar på tal:</p>



<p><a href="https://sulkysport.se/valde-sulkyn-framfor-diskhon/" data-type="link" data-id="https://sulkysport.se/valde-sulkyn-framfor-diskhon/" target="_blank" rel="noreferrer noopener">– Jag kan inte tjäna 500.000 dollar per år genom att stå hemma och diska…</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/08/farberbea070801-617x342.jpg" alt="" class="wp-image-105637"/><figcaption class="wp-element-caption">Bea Farber. Foto: Stefan Melander/stalltz.se</figcaption></figure>



<h2 class="wp-block-heading">Fattas 30 segrar</h2>



<p>I Sverige är <strong>Kajsa Frick </strong>etta med 970 vinster och det fattas 30 segrar innan hon blir den första kvinnliga medlemmen i Tusenklubben i Sverige.</p>



<p>Andra segerrika kvinnor är ryskan <strong>Alla Polzunova,</strong> som vann över 900 segrar under sin aktiva karriär innan hon fick en central roll i det ryska centralförbundet. </p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/03/image3.jpg" alt="" class="wp-image-558882"/><figcaption class="wp-element-caption">Alla Polzunova och Delvin Miller.</figcaption></figure>



<p>1956 började hon köra lopp på hippodromen i Moskva och erhöll senare titeln ”mästerkusk.” Hon tävlade aldrig i Sverige, men körde lopp i Finland, Holland, Tyskland, Ungern och USA.</p>



<p><a href="https://harnesslink.com/europe/alla-polzunova-84-dies/" data-type="link" data-id="https://harnesslink.com/europe/alla-polzunova-84-dies/" target="_blank" rel="noreferrer noopener">För snart tre år sedan gick Alla Polzunova bort i 84 års ålder.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">Kvinnornas intåg i travsporten har inte alltid setts med blida ögon. Idag  syns de överallt, i stallar, på banor, i sulkyn och i inte minst i tv-rutan som intervjuare, programledare, spelexperter – ja, i alla roller! </p>



<p>Travsporten är inte längre den manliga borg som den en gång i tiden var. <br>All hantering av travsport har ju traditionellt förknippats med manlighet och från den utgångspunkten är det inte svårt att varifrån uttrycket ”hästkarl” härstammar. </p>



<p>Länge var det förbjudet för kvinnor att inneha proffslicens i Sverige och inte förrän den 26 maj 1970 gav travförbundet med sig i frågan. Innan det datumet fick kvinnorna inte ens köra proffslopp mot män. Det är inte bara i Sverige som haft denna ålderdomliga syn på kvinnors duglighet inom travets värld.</p>



<h2 class="wp-block-heading">Avstängd för graviditet</h2>



<p>I vårt grannland Danmark  stängdes en gång i tiden en kvinna av från all tävling på grund av att hon var gravid. Ja, ni läste rätt!</p>



<p>Ordföranden i det danska centralförbundet lade inga fingrar emellan och i ett officiellt uttalande i dansk press sade <strong>Mogens Ericksen</strong>: </p>



<p>– Ston får inte tävla när de skall föla, då får inte heller en travtränare som är med barn göra det!</p>



<p>Ord och inga visor, men den drabbade <strong>Lena Hansen</strong> var inte den som gav vika:  </p>



<p>– Graviditet är ingen sjukdom. Det här ska inte förbundet blanda sig i. Jag är själv kapabel att avgöra om jag kan köra eller ej. </p>



<h2 class="wp-block-heading">”Lena, nu i femte månaden, var i fin form”</h2>



<p>Det danska travförbundet fick ta emot hård kritik i dagspressen för sitt agerande och tvingades till slut backa för dumheterna. Det var inte heller något fel på Lena Hansens form när beslutet upphävdes. Tidningen Politiken i Köpenhamn rapporterade första tävlingsdagen efter hon var fri att tävla på Lolland-Falster: </p>



<p><em>”Lena Hansen, dansk idrotts mest diskuterade namn för närvarande, gav ett klart svar om hon kan köra eller inte, då hon dels vann med Larissa, dels blev tvåa med Lille Claus efter två fina körningar. Lena, nu i femte månaden, var i fin form.”</em></p>



<p>Sedan den dagen kommer aldrig frågan mer upp om en gravid kvinna skulle få köra lopp&#8230;</p>



<h2 class="wp-block-heading">”Inga kvinnliga kuskar”</h2>



<p>Men svenska centralförbundet, dåvarande STC, var inte bättre. Generalsekreterare <strong>Einar Sörensen</strong> var mycket klar i syn på kvinnor. Om huvudstadsbanan, där han tidigare varit sekreterare, uttryckte han sig: </p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/skarmavbild20240307kl.16.08.33-350x413.jpg" alt="" class="wp-image-558885"/><figcaption class="wp-element-caption">Einar Sörensen. </figcaption></figure>



<p>– Solvalla ska ha alltigenom en professionell travsport. Inga kvinnliga kuskar. </p>



<p>Samma sak ansåg hövdingarna på Vincennes. Ryskan <strong>Maria Burdova</strong> förbjöds att köra Prix d’Amérique 1965 med Pack Hanover för att hon just var kvinna. Sedan upphävde fransmännen detta beslut och det har inte minst glatt oss svenskar. 1995 vann <strong>Helen A Johansson</strong> Prix d’Amérique med Ina Scot och numera har hon ett lopp uppkallat sig efter på Vincennes Prix d’Amérique-dag&#8230;</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-embed is-type-wp-embed is-provider-sulkysport wp-block-embed-sulkysport"><div class="wp-block-embed__wrapper">
<blockquote class="wp-embedded-content" data-secret="sFpHKCGXmh"><a href="https://sulkysport.se/kronika/hemmets-harskarinnor-tar-over-travbanorna/">”Hemmets härskarinnor tar över travbanorna”</a></blockquote><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="””Hemmets härskarinnor tar över travbanorna”” &ndash; Sulkysport" src="https://sulkysport.se/kronika/hemmets-harskarinnor-tar-over-travbanorna/embed/#?secret=OEyyLgepnY#?secret=sFpHKCGXmh" data-secret="sFpHKCGXmh" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe>
</div></figure>
