
<p class="has-drop-cap wp-block-paragraph">Stig H Johansson och Åke Svanstedt har dominerat i tränarhistorien med fyra vinster vardera. Stig H:s segerhästar är <strong>Don Ego, Utah Bulwark</strong> och <strong>Queen L. </strong>(två gånger), medan Åke tog tre raka segrar med <strong>Gidde Palema</strong> och vann även med <strong>Torvald Palema</strong>.<br>Två tränarsegrar ståtar Erik Berglöf, Veijo Heiskanen, Stefan Hultman, Lars Marklund, Fabrice Souloy och Jori Turja med.</p>



<p class="wp-block-paragraph">Daniel Redén har vunnit loppet en gång, då norske <strong>Lionel</strong> (e. Look de Star) segrade 2017 med ägaren Göran Antonsen i vagnen. Nu mönstrar Daniel <strong>Kentucky River</strong> (e. Father Patrick), för tredje året i rad, och framför allt stallets mångmiljonär <strong>Francesco Zet</strong> (e. Father Patrick). </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/francescozetdr260125adam-617x333.jpg" alt="" class="wp-image-816286"/><figcaption class="wp-element-caption">Daniel Redén värmer upp Francesco Zet inför Prix d&#8217;Amérique 2026. Nu väntar Paralympiatravet. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Francesco Zet gör första starten på svensk mark efter en vinner som innehöll raketspurt som oplacerad i Prix d’Amerique, bronspeng i Prix de France och fjärdeplats i Pris de Paris.<br>– Francesco Zet har varit i en bra fas länge nu och jag är väldigt nöjd med hur han agerar och jag kan köra honom lite som jag vill numera i jobben. Han fick ett rejält jobb i måndags och jag tror inte han är i behov av lopp i kroppen utan brukar leverera direkt. Jag är nöjd med spåret och han kan ju öppna bra från start, säger Daniel Redén på sin hemsida <a href="http://reddis.se">reddis.se</a>.</p>



<h2 class="wp-block-heading">Startlista Paralympiatravet 2026</h2>



<p class="wp-block-paragraph">2.140 meter autostart<br><strong>Pris: </strong>1.500.000-700.000-325.000-150.000-75.000-40.000-30.000-25.000 kr<br><em>Häst (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li><strong>Kentucky River</strong> (e. Father Patrick) – Carl Johan Jepson (Daniel Redén)</li>



<li><strong>Luke the Spook</strong> (e. Greenshoe) – Adrian Kolgjini</li>



<li><strong>Harley Gema</strong> (e. Bold Eagle) – Björn Goop (Marc Sassier)</li>



<li><strong>Powwow</strong> (e. Papagayo E.) – Mats E Djuse (Jan Kristian Waaler)</li>



<li><strong>Daim Brodda</strong> (e. Readly Express) – Eirik Höitomt (Kjetil Helgestad)</li>



<li><strong>Francesco Zet</strong> (e. Father Patrick) – Örjan Kihlström (Daniel Redén)</li>



<li><strong>H.C.’s Crazy Horse</strong> (e. S.J.&#8217;s Caviar) – Daniel Wäjersten</li>



<li><strong>Charron</strong> (e. Code Bon) – Magnus Teien Gundersen (Geir Vegard Gundersen)</li>



<li><strong>Önas Prince</strong> (e. Chocolatier) – Per Nordström</li>



<li><strong>Get A Wish</strong> (e. Wishing Stone) – Robert Bergh</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">Kärt barn har många namn och lördagens storlopp på Åby, Paralympiatravet, har haft flera under åren. Vid premiären 1979 var namnet Guldmedaljen och loppet var placerat utanför V65-kupongen.<br>Även året efter var det Guldmedaljen som gällde innan det – efter att ha varit inställt 1981 – var premiär för Olympiatravet 1982. 2020 blev det nya namnet Paralympiatravet, sedan det skrivits avtal med Sveriges Paralympiska Kommitté och Parasport.</p>



<p class="wp-block-paragraph">Efter premiäråret på Jägersro var Solvalla arrangör 1980 och 1984 (fyraåringslopp det året) och Åby 1982. Sedan 1985 har Olympiatravet/Paralympiatravet varit bosatt på Åby. Två gånger har Olympiatravet ställts in, 1981 och 1983.</p>



<p class="wp-block-paragraph">1985 började Olympiatravet ta fart när det gällde prispengar. Från 75.000 till 300.000 kronor i förstapris. Torbjörn Jansson triumferade bakom svensk travsports nya superstar <strong>Meadow Road</strong>. Samma år vann han också Elitloppet och båda avdelningarna i Statue of Liberty Trot.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/01/lahdekorpihakansson-617x333.jpg" alt="" class="wp-image-683245"/><figcaption class="wp-element-caption">Egon Håkansson efter Gentlemans seger i försök till Olympiatravet, där hästen senare vann även finalen i regi Kari Lähdekorpi. Foto ALN</figcaption></figure>



<p class="wp-block-paragraph">Mannen bakom Olympiatravets tillkomst och premiär 1979 var Egon Håkansson, som avled i början av 2025. För många är Egon mer känd som ”Mr Basket” som den pionjär han var för sporten i Sverige, landets första idrottspromotor och namngivare av Globen, men Håkansson var ett stort namn i travkretsar också.<br>Egon var även delägare i <strong>Gentleman</strong> (e. Gentle Star), 1.10,9ak/4.809.621 kr, som vann Sprintermästaren, Olympiatravet (!) och Jämtlands Stora Pris bland 21 segrar på 51 starter.</p>



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



<p class="has-drop-cap wp-block-paragraph">En tidigare vinnare finns bland de tio deltagarna. För två år sedan segrade Per Nordström med sin stjärna <strong>Önas Prince</strong> (e. Chocolatier) och hästen var även fyra i fjolårets högklassiga final bakom Borups Victory, San Moteur och Inmarosa.</p>



<p class="wp-block-paragraph">Önas Prince gör – nio år gammal – sin sista säsong på tävlingsbanorna och första stora målet är alltså Paralympiatravet. Hur det blir sedan återstår att se, men Nordström verkar inte särskilt intresserad av att göra ett fjärde försök i Elitloppet, där Önas Prince gått till final varje gång och har fjärdeplatsen 2023 som bästa resultat.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/onasprincepnm240504adamstromstalltz-617x393.jpg" alt="" class="wp-image-579925"/><figcaption class="wp-element-caption">Önas Prince vann Paralympiatravets final 2024 på 1.10,1 – loppets näst snabbaste notering i historien. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Önas Prince notering vid segerloppet är den tredje snabbaste i loppets historia. Bara Ringostarr Treb och Borups Victory har travat fortare, en tiondel. </p>



<p class="wp-block-paragraph"><strong>Snabbaste vinnarna av Olympiatravet/Paralympiatravet genom tiderna:</strong><br><em>År, vinnare (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2018 <strong>Ringostarr Treb</strong> (e. Classic Photo) – Wim Paal (Jerry Riordan) – 1.10,0a</li>



<li>2025 <strong>Borups Victory</strong> (e. Googoo Gaagaa) – Daniel Wäjersten – 1.10,0a</li>



<li>2024 <strong>Önas Prince</strong> (e. Chocolatier) – Per Nordström – 1.10,1a</li>



<li>2015 <strong>B.B.S.Sugarlight</strong> (e. Super Light) – Peter Untersteiner (Fredrik Solberg) – 1.10,7a</li>



<li>2023 <strong>San Moteur</strong> (e. Panne de Moteur) – Björn Goop – 1.10,8a</li>



<li>2014 <strong>Solvato</strong> (e. Donato Hanover) – Veijo Heiskanen – 1.10,9a</li>



<li>2016 <strong>Your Highness</strong> (e. Chocolatier) – Björn Goop (Fabrice Souloy) – 1.10,9a</li>



<li>2017 <strong>Lionel</strong> (e. Look de Star) – Göran Antonsen (Daniel Redén) – 1.10,9a</li>



<li>2021 <strong>Delia du Pommereux</strong> (e. Niky) – Erik Raffin (Sylvain Roger) – 1.10,9a</li>



<li>2013 <strong>Maharajah</strong> (e. Viking Kronos) – Örjan Kihlström (Stefan Hultman) – 1.11,0a</li>



<li>2019 <strong>Handsome Brad</strong> (e. Brad de Veluwe) – Carl Johan Jepson (Ulf Stenströmer) – 1.11,0a</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Förstapriset var 1,5 miljoner kronor åren 2008 till 2019, men 2020 sänktes det till miljonen jämnt i spåren av coronapandemin. Sedan 2021 är den stora prischecken återställd och den summan kvitterade <strong>Borups Victory</strong> ut förra året.<br>Daniel Wäjerstens travade hade en plats i loppet, men valde att tacka nej och satsar mot Elitloppet. Därmed blir fortsatt <strong>Queen L, Copiad</strong> och <strong>Gidde Palema</strong> ensamma om att försvara titeln i Olympia- och Paralympiatravet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/06/hcscrazyhorseplm240629adamstromstalltz-617x424.jpg" alt="" class="wp-image-602972"/><figcaption class="wp-element-caption">Spurtstarke H.C.&#8217;s Crazy Horse, här med Per Linderoth, är Daniel Wäjerstens hopp. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Wäjersten kunde haft tre hästar i finalen, men tackade även nej med <strong>Mellby Jinx</strong> som vann sista chansen på Umåker förra lördagen. Hans hopp blir <strong>H.C.’s Crazy Horse</strong> (e. S.J.’s Caviar), som segrade i uttagningsloppet i Bollnäs och nu får sitt riktiga elddop i eliten.<br>Hästen kan också titulera sig svensk rekordhållare. I Rättvik på sommaren som fyraåring 2023 vann han försök till bronsdivisionen på 1.11,8/2.140 meter voltstart med tränare Wäjersten i vagnen. Det tiden står sig fortfarande som svenskt rekord.</p>



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



<p class="has-drop-cap wp-block-paragraph">5ston har vunnit Olympiatravet. Först ut var <strong>Jana Bloc</strong> 1982 och hon har följts av <strong>Grades Singing</strong> 1987, <strong>Queen L.</strong> 1993 och 1994 och sedan dröjde det till <strong>Your Highness</strong> 2016. 2021 sällade sig fransyskan <strong>Delia du Pommereux</strong> (e. Niky) till den skaran.<br>Årets hopp på stosidan kommer från Frankrike och Norge i form av <strong>Harley Gema</strong> (e. Bold Eagle) och svenskfödda <strong>Daim Brodda</strong> (e. Readly Express). </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/01/scoopdyga123367002-617x411.jpg" alt="" class="wp-image-809862"/><figcaption class="wp-element-caption">Harley Gema vid sin spurtseger i Prix de la Cote d’Azur för Benjamin Rochard. Foto: Scoopdyga</figcaption></figure>



<p class="wp-block-paragraph">Ingen fransk häst har vunnit loppet sedan just Delia du Pommereux triumferade för<br>fem år sedan och nu är det upp till Marc Sassiers nioåriga märr Harley Gema av bryta den segerlösa sviten.<br>Harley Gema har haft en fin vinter på franska rivieran och spurtade först hem Prix de la Cote d’Azur (€120.000) i Cagnes-sur-Mer för Benjamin Rochard och slutade sedan tvåa i sprinterslaget Grand Criterium de Vitesse (€200.000) på samma bana i mars bakom Iguski Sautonne. Då travade Harley Gema sitt rekord 1.08,9ak.<br>Stoet har flera starka säsonger bakom sig och ifjol vann hon försök i Grand National du Trot (€90.000) i Mauquenchy och Grand Prix de la Ville de Laval (€70.000) i Laval. Dessutom var hon tvåa bakom <strong>Ino du Lupin</strong> i Grand Prix du Centre Est (€100.000).</p>



<p class="wp-block-paragraph">Björn Goop är anlitad som kusk vid första utlandsresan och Björn har tre segrar som körsven: <strong>Thai Tanic, Your Highness</strong> och <strong>San Moteur</strong>.<br>– Naturligtvis hade det varit bättre att ha Benjamin (Rochard) som känner henne perfekt, men vi har också storlopp i Caen där vi kommer att ha Mojito Fraise, säger tränaren Marc Sassier till Paris-Turf.</p>



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



<p class="has-drop-cap wp-block-paragraph">Paralympiatravet är det riktiga startskottet för storloppssäsongen för den äldre eliten i Sverige och om drygt tre veckor stundar Elitloppet på Solvalla. Att vinna Åbys storlopp och sedan fortsätta med att plocka hem Elitloppet några veckor senare har åtta hästar lyckats med.</p>



<ul class="wp-block-list">
<li>1979 – <strong>Pershing</strong> (e. Nevele Pride) – Berndt Lindstedt</li>



<li>1985 – <strong>Meadow Road</strong> (e. Madison Avenue) – Torbjörn Jansson</li>



<li>1995 – <strong>Copiad</strong> (e. Texas) – Erik Berglöf</li>



<li>2002 – <strong>Varenne</strong> (e. Waikiki Beach) – Giampaolo Minnucci (Jori Turja)</li>



<li>2004 – <strong>Gidde Palema</strong> (e. Alf Palema) – Åke Svanstedt</li>



<li>2011 – <strong>Brioni</strong> (e. Timberland) – Joakim Lövgren</li>



<li>2012 – <strong>Commander Crowe</strong> (e. Juliano Star) – Christophe Martens (Fabrice Souloy)</li>



<li>2018 – <strong>Ringostarr Treb</strong> (e. Classic Photo) – Wim Paal (Jerry Riordan)</li>
</ul>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/05/sugarcanehanoverolympia-617x333.jpg" alt="" class="wp-image-589679"/><figcaption class="wp-element-caption">Sugarcane Hanover och Gunnar Eggen vid utklassningssegern i Olympiatravet 1988. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">S<strong>ugarcane Hanovers </strong>triumf 1988 är fortfarande för många det största ögonblicket i loppets historia när han vann i överlägsen stil för Gunnar Eggen och utklassade världsmästaren <strong>Callit</strong>. Sugarcane Hanover värmde dåligt, men gjorde sina motståndare till statister när det blev allvar.<br>Han svepte runt sina konkurrenter till spets redan innan sista kurvan och vann på 1.14,4a/2.140 meter, medan Callit noterade 1.15,6 som tvåa – akterseglad med ”många längder.”</p>



<p class="wp-block-paragraph">Gunnar Eggen är inte ensam norrman att ha vunnit. Göran Antonsen satt upp bakom ögonstenen <strong>Lionel</strong> (e. Look de Star) – i träning hos Daniel Redén – och blåste runt alla konkurrenter till seger 2017.</p>



<p class="wp-block-paragraph">I år mönstrar de norska tränarna ett stort lag, då en trio bjutits in till loppet. Förutom stoet Daim Brodda startar även <strong>Powwow</strong> (e. Papagayo E.) och <strong>Charron</strong> (e. Code Bon).<br>Daim Brodda har vunnit 14 av 22 starter och bland vinsterna finns Derbystoet och finalen i Breeders Crown för fyraåringar från 2024. Ifjol slutade hon bland annat tvåa i Ulf Thoresen Grand International och trea i Hugo Åbergs Memorial. </p>



<p class="wp-block-paragraph">Sexårige Powwow har faktiskt bara hunnit med 18 starter på vunnit två av dessa. Senaste segern ligger så långt tillbaka i tiden som i norska Kriteriekvalet i september 2023, men hästen är berest och har tävlat både i USA, Frankrike och Sverige. Halvparten av hästens prispengar kommer från förra höstens tredjeplats i VM-loppet på Yonkers Raceway.</p>



<p class="wp-block-paragraph">Kullkamraten <strong>Charron</strong> (e. Code Bon) tog hem norska Derbyt för två år sedan och var med i Elitloppet ifjol. Han vann just denna tävlingsdag på Åby förra året. Då handlade det om Lyons lopp för femåringar.</p>



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



<p class="has-drop-cap wp-block-paragraph">Hemmahoppet i Paralympiatravet är Robert Bergh med bereste dansken <strong>Get A Wish</strong> (e. Wishing Stone). Hästen Get A Wish vann bland annat danska Derbyt i regi Bo Westergård innan han flyttades till Johan Untersteiner på våren 2024. Där blev det seger i Guldsprintern i Halmstad under Sprintermästarhelgen och en andraplats bakom <strong>Borups Victory</strong> i Hugo Åbergs Memorial.</p>



<p class="wp-block-paragraph">Get A Wish bjöds in till VM-loppet på Yonkers Raceway på hösten, där det dock blev galopp. Efter loppet blev han kvar i USA hos Åke Svanstedt, innan han återvände till skandinavisk och svensk mark i år. Nu i träning hos Robert Bergh.<br>– Get A Wish har tränat på positivt efter årsdebuten. Det blir barfota runt om och sulky, säger Robert Bergh på sin hemsida.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/lukethespook2-617x361.jpg" alt="" class="wp-image-618005"/><figcaption class="wp-element-caption">Mattias Melander bakom Luke the Spook på Red Mile 2024. Foto: Amanda Stephens</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4USA-födda hästar har stått som segrare i Olympiatravet/Paralympiatravet. Pershing var först ut redan i premiärupplagan 1979 och han har följts av Grades Singing 1987, Sugarcane Hanover 1988 och Bo Näslunds storskräll Karate Chop 1991. Sedan dess är det tomt på amerikanska triumfer.</p>



<p class="wp-block-paragraph">Ska den 27-åriga segertorkan brytas i år är det upp till femårige <strong>Luke the Spook</strong> (e. Greenshoe), som tränas och körs av Adrian Kolgjini.</p>



<p class="wp-block-paragraph">Luke the Spook tävlade som två- och treåring i Marcus Melanders regi i USA och vann sex av 21 starter. Premiärsäsongen i Europa förra året gav goda resultat, bland annat andraplatsen i Kungapokalen och ett fjärdepris i Sprintermästaren. I senaste starten slutade han tvåa bakom Önas Prince i uttagningsloppet till Paralympiatravet.</p>



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



<p class="has-drop-cap wp-block-paragraph">Två avelshingstar har fyra vinnare vardera i Olympiatravet/Paralympiatravet. Texas var först till fyra med <strong>Grades Singing</strong> 1987, <strong>Karate Chop</strong> 1991 och <strong>Copiad</strong> 1995, 1996.<br>Alf Palema fördelade sina fyra vinster på två avkommor; <strong>Gidde Palema</strong> 2003, 2004, 2005 och <strong>Torvald Palema</strong> 2008.</p>



<p class="wp-block-paragraph">Tre vinnare i Olympiatravet har Viking Kronos: <strong>Thai Tanic</strong> 2006, <strong>Triton Sund</strong> 2009 och <strong>Maharajah</strong> 2013.<br>Trion Crowntron, Super Play och Waikiki Beach står med två dubbelvinnare vardera: <strong>Queen L. </strong>(1993, 1994), <strong>Scandal Play</strong> (1997, 1999) och <strong>Varenne</strong> (2000, 2002).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/03/kentuckyriverok-617x333.jpg" alt="" class="wp-image-828461"/><figcaption class="wp-element-caption">Daniel Redén-tränade Kentucky River och Örjan Kihlström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph"><strong>Maharajah</strong> (e. Viking Kronos) och sonen <strong>Who’s Who</strong> är historiska. Det är första gången en far och son stått som vinnare i storloppet. Pappa Maharajah gjorde när han vann Olympiatravet 2013 på 1.11,0a/2.140 meter tillsammans med Örjan Kihlström och Who’s Who följde upp 2022 – med gemensam ägare, uppfödare och kusk dessutom: Travkompaniet, Menhammar Stuteri och Örjan Kihlström.</p>



<p class="wp-block-paragraph">i år saknas en avkomma till Maharajah i Paralympiatravet och av fäderna bakom årets finalister har blott tre haft finalister tidigare. En av dem har en vinnare, Chocolatier genom <strong>Önas Prince</strong>, som är pappans hopp även i år.</p>



<p class="wp-block-paragraph">Father Patrick är ensam om två finalister och sonen Kentucky River startar för tredje gången. För två år sedan slutade han tvåa bakom just Önas Prince.</p>



<p class="wp-block-paragraph"><strong>Avelshingstarna i Paralympiatravet</strong><br><em>Avelshingst (finalist 2026) – Tidigare finalister – Resultat</em></p>



<ul class="wp-block-list">
<li><strong>Bold Eagle</strong> (1) – 1 – Aetos Kronos (3) 2021</li>



<li><strong>Chocolatier</strong> (1) – 6 – El Mago Pellini (0) 2015, Your Highness (1) 2016, Your Highness (2) 2017, Extreme (2) 2017, Önas Prince (1) 2024, Önas Prince (4) 2025</li>



<li><strong>Father Patrick</strong> (2) – 2 – Kentucky River (2) 2024, Kentucky River (6) 2025</li>
</ul>



<p class="wp-block-paragraph"><strong>Code Bon</strong> (1), <strong>Greenshoe</strong> (1), <strong>Papagayo E.</strong> (1), <strong>Readly Express</strong> (1), <strong>S.J.’s Caviar</strong> (1) och <strong>Wishing Stone</strong> (1) har inte haft startande avkommor tidigare.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/10/daimbroddapris2-617x333.jpg" alt="" class="wp-image-784968"/><figcaption class="wp-element-caption">Eirik Höitomt, Stian Hallenstvedt och Maria Widnes tillsammans med Daim Brodda. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><strong>Här är hästskötarna bakom de tio finalisterna i Paralympiatravet:</strong></p>



<ul class="wp-block-list">
<li>Kentucky River – Ellinor Wennebring</li>



<li>Luke the Spook – Agnes Carlsson</li>



<li>Harley Gema – Alexis Bescher</li>



<li>Powwow – Ragnhild Diesen</li>



<li>Daim Brodda – Maria Widnes</li>



<li>Francesco Zet – Carolina Persson</li>



<li>H.C.’s Crazy Horse – Johanna Nordin</li>



<li>Charron – Lise Haugen Alme</li>



<li>Önas Prince – Emma Nordström</li>



<li>Get A Wish – Natalie Vingmyr</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">Alla deltagare i Paralympiatravet kommer att vara uppstallade i övervakningsstall inför loppet, detta i enlighet med paragraf 5 i Antidopningsreglementet. Det innebär att startande hästar i loppet måste vara på plats i anvisat stall på Åby klockan 08.00-10.00 på lördagen.</p>



<p class="wp-block-paragraph">Det är första gången i år som ST har övervakningsstall i ett lopp.</p>


<div class="factbox full ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Alla vinnare av Paralympiatravet								</h3>
<div class="content">
<p class="wp-block-paragraph"><em>År, vinnare – Kusk (tränare) – Segertid – Förstapris (kr)</em><br />1979 <strong>Pershing</strong> – Berndt Lindstedt – 1.17,9a/2.100 – 60.000<br />1980 <strong>Don Ego</strong> – Stig H Johansson – 1.18,4/2.140 – 40.000<br />1981 Inställt<br />1982 <strong>Jana Bloc</strong> – Ove R Andersson – 1.18,8/2.140 – 40.000<br />1983 Inställt<br />1984 <strong>Einarsin</strong> – Tapio Perttunen – 1.15,1a/2.140 – 75.000<br />1985 <strong>Meadow Road</strong> – Torbjörn Jansson – 1.15,5a/2.140 – 300.000<br />1986 <strong>Utah Bulwark</strong> – Stig H Johansson – 1.14,5a/2.140 – 300.000<br />1987 <strong>Grades Singing</strong> – Ulf Thoresen (Herve Filion) – 1.15,4a/2.140 – 300.000<br />1988 <strong>Sugarcane Hanover</strong> – Gunnar Eggen – 1.14,4a/2.140 – 400.000<br />1989 <strong>Callit</strong> – Karl O Johansson – 1.14,9a/2.140 – 400.000<br />1990 <strong>Jet Ribb</strong> – Hans G Eriksson – 1.14,6a/2.140 – 500.000<br />1991 <strong>Karate Chop</strong> – Bo Näslund – 1.15,1a/2.140 – 500.000<br />1992 <strong>Bravo Sund</strong> – Jorma Kontio (Veijo Heiskanen) – 1.14,3a/2.140 – 500.000<br />1993 <strong>Queen L.</strong> – Stig H Johansson – 1.14,3a/2.140 – 500.000<br />1994 <strong>Queen L.</strong> – Stig H Johansson – 1.13,8a/2.140 – 500.000<br />1995 <strong>Copiad</strong> – Erik Berglöf – 1.13,6a/2.140 – 500.000<br />1996 <strong>Copiad</strong> – Erik Berglöf – 1.13,9a/2.140 – 800.000<br />1997 <strong>Scandal Play</strong> – Bo Eklöf (Lars Marklund)– 1.13,7a/2.140 – 800.000<br />1998 <strong>Rival Damkaer</strong> – Erik Adielsson (Tommy Strandqvist) – 1.16,2a/2.140 – 800.000<br />1999 <strong>Scandal Play</strong> – Bo Eklöf (Lars Marklund) – 1.14,8a/2.140 – 800.000<br />2000 <strong>Varenne</strong> – Giampaolo Minnucci (Jori Turja) – 1.12,7a/2.140 – 800.000<br />2001 <strong>Etain Royal</strong> – Jorma Kontio (Pirjo Vauhkonen) – 1.13,2a/2.140 – 800.000<br />2002 <strong>Varenne</strong> – Giampaolo Minnucci (Jori Turja) – 1.12,4a/2.140 – 800.000<br />2003 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.13,1a/2.140 – 800.000<br />2004 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.12,9a/2.140 – 800.000<br />2005 <strong>Gidde Palema</strong> – Åke Svanstedt – 1.12,9a/2.140 – 800.000<br />2006 <strong>Thai Tanic</strong> – Björn Goop (Olle Goop) – 1.13,0a/2.140 – 1.000.000<br />2007 <strong>Gentleman</strong> – Thomas Uhrberg (Kari Lähdekorpi) – 1.12,8a/2.140 – 1.000.000<br />2008 <strong>Torvald Palema</strong> – Åke Svanstedt – 1.12,2a/2.140 – 1.500.000<br />2009 <strong>Triton Sund</strong> – Örjan Kihlström (Stefan Hultman) – 1.11,1a/2.140 – 1.500.000<br />2010 <strong>Copper Beech</strong> – Conrad Lugauer – 1.11,6a/2.140 – 1.500.000<br />2011 <strong>Brioni</strong> – Joakim Lövgren – 1.11,4a/2.140 – 1.500.000<br />2012 <strong>Commander Crowe</strong> – Christophe Martens (Fabrice Souloy) – 1.12,2a/2.140 – 1.500.000<br />2013 <strong>Maharajah</strong> – Örjan Kihlström (Stefan Hultman) – 1.11,0a/2.140 – 1.500.000<br />2014 <strong>Solvato</strong> – Veijo Heiskanen – 1.10,9a/2.140 – 1.500.000<br />2015 <strong>B.B.S.Sugarlight</strong> – Peter Untersteiner (Fredrik Solberg) – 1.10,7a/2.140 – 1.500.000<br />2016 <strong>Your Highness</strong> – Björn Goop (Fabrice Souloy) – 1.10,9a/2.140 – 1.500.000<br />2017 <strong>Lionel</strong> – Göran Antonsen (Daniel Redén) – 1.10,9a/2.140 – 1.500.000<br />2018 <strong>Ringostarr Treb</strong> – Wim Paal (Jerry Riordan) – 1.10,0a/2.140 – 1.500.000<br />2019 <strong>Handsome Brad</strong> – Carl Johan Jepson (Ulf Stenströmer) – 1.11,0a/2.140 – 1.500.000<br />2020 <strong>Elian Web</strong> – Jorma Kontio (Katja Melkko) – 1.12,2a/2.140 – 1.000.000<br />2021 <strong>Delia du Pommereux</strong> – Eric Raffin (Sylvain Roger) – 1.10,9a/2.140 – 1.500.000<br />2022 <strong>Who&#8217;s Who</strong> – Örjan Kihlström (Pasi Aikio) – 1.11,9a/2.140 meter – 1.500.000<br />2023 <strong>San Moteur</strong> – Björn Goop – 1.10,8a/2.140 – 1.500.000<br />2024 <strong>Önas Prince</strong> – Per Nordström – 1.10,1a/2.140 meter – 1.500.000<br />2025 <strong>Borups Victory</strong> – Daniel Wäjersten – 1.10,0a/2.140 meter – 1.500.000</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
