
<p class="has-drop-cap wp-block-paragraph">Den ene har varit med i Elitloppsfinal två år i rad. Den andre vann Sweden Cup förra året. Lördagens Paralympiatravsfinal ser ut att bli en match mellan två försöksfinnare som båda har större mål i sikte: Elitloppet om drygt tre veckor!</p>



<p class="wp-block-paragraph">Per Nordström-tränade <strong>Önas Prince</strong> (e. Chocolatioer) tvingades avsluta fjolårssäsongen i förtid och lägga sig på operationsbordet när en benflisa plockades bort. Innan dess hade hunnit med att vinna Copenhagen Cup och slutat fyra i Elitloppsfinalen. Efter operationen har han gjort två starter i vår och vunnit båda och vann sitt försök från dödens med en mycket nöjd tränare Nordström i sulkyn.<br>Önas Prince slog i ena hjulet vid uppkörningen bakom bilen och i startögonblicken, vilket fått Nordström att köpa en ny vagn till lördagens final där Önas Prince får bättre plats.</p>



<p class="wp-block-paragraph">Alessandro Gocciadoro-tränade <strong>Bengurion Jet</strong> (e. Maharajah) vann visserligen vara ett lopp förra året, men hade ändå en toppsäsong med bland annat pallplatser i Åby Stora Pris, VM-loppet, Finlandia-Ajo och Seinäjoki Race, och kronan på verket segern i Sweden Cup-finalen på Elitloppslördagen.<br>På Jägersro lekte han hem sitt paraförsök på skarpa 1.10,6a/2.140 meter.<br>– Han var väldigt bra senast på Jägersro och bättre än jag hade förväntat mig, men ändå inte i toppslag utan jag förväntar mig att formen ska komma ännu mer nu i takt med att han fått två lopp i kroppen. Hästen har tränat på normalt efteråt, jag är mycket nöjd med startspåret och ska göra ett ordentligt försök att hålla ledningen eller åtminstone hamna långt fram. Det blir barfota på nytt och jänkarvagn. Senast valde jag att köra med öppet huvudlag, men det finns fortfarande med som alternativ nu att stänga in honom lite mer, säger Alessandro Gocciadoro.</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/02/beartime1cjjvc240224-617x333.jpg" alt="" class="wp-image-554765"/><figcaption class="wp-element-caption">Helena Edlund-tränade Beartime och Carl Johan Jepson vann Express Gaxes lopp. Foto Gunilla König/Stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Amatörtränade hästar kryllar det inte av i landets storlopp, men i Olympiatravet och Paralympiatravet har det firats framgångar genom åren. Herbert Wallin från dalsländska Bengtsfors tränade duktiga stoet <strong>Jana Bloc</strong> (e. Train Bloc), som tillsammans med Ove R Andersson segrade 1982. Pirjo Vaukonen var kvinnan bakom <strong>Etain Riyal</strong> (e. Ulf d’Ombree) vid triumfen med Jorma Kontio 2001.<br>Norrmannen Fredrik Solberg är senast i raden då hans ögonsten <strong>B.B.S.Sugarlight</strong> (e. Super Light) triumferade tillsammans med Peter Untersteiner 2015.</p>



<p class="wp-block-paragraph">I år vänds amatörernas blickar mot Värmland och <strong>Beartime</strong> (e. Pastor Stephen), som tränas av rutinerade Årjängsamatören Helena Edlund med mångårig erfarenhet som hästskötare hos bland andra Jim Frick och Stig H Johansson. Beartime har haft en fin vinter och vår med gulddivisionssegrar i Express Gaxes Lopp och norska Steinlagers Äreslopp.</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. För tre år sedan sällade sig även fransyskan <strong>Delia du Pommereux</strong> till den skaran.</p>



<p class="wp-block-paragraph">2024 års upplaga saknar dock ston i startlistan, sedan fransyskan <strong>Emeraude de Bais</strong> (e. Repeat Love), 1.08,3ak/€828.760, bjudits in till Åbys storlopp, men tackat nej. Fem hingstar och lika många valacker gör upp om segern.</p>



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



<p class="wp-block-paragraph"><em>För treåriga och äldre hästar, 2.140 meter autostart:</em><br><strong>Pris:</strong> 1.500.000-700.000-325.000-150.000-75.000-40.000-30.000-25.000 kr<br><em>Namn (far) – Kusk (tränare)</em></p>



<ol class="wp-block-list">
<li>Bengurion Jet (e. Maharajah) – Alessandro Gocciadoro</li>



<li>Castor the Star (e. Maharajah) – Mats E Djuse (Jörgen Westholm)</li>



<li>Dorgos de Guez (e. Romcok de Guez) – Magnus A Djuse (Frode Hamre)</li>



<li>Rackham (e. Love You) – Christoffer Eriksson</li>



<li>Beartime (e. Pastor Stephen) – Carl Johan Jepson (Helena Edlund)</li>



<li>Unico Broline (e. Cantab Hall) – Erik Adielsson (Sofia Aronsson)</li>



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



<li>King Schermer (e. Trixton) – Michel F. Rothengatter</li>



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



<li>Usain Töll (e. Googoo Gaagaa) – Björn Goop (Vitale Ciotola)</li>
</ol>



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



<p class="wp-block-paragraph"><strong>Inga ston alltså, men väl två av tio finalister tränade av kvinnor. Förutom nämnde Beartime har Sofia Aronssons topphäst Unico Broline (e. Cantab Hall) bjudits in efter att ha slutat tvåa bakom Bengurion Jet i försöket på Jägersro.</strong></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/2021/05/pershingolympiatravet-617x333.jpg" alt="" class="wp-image-159998"/><figcaption class="wp-element-caption">Ingemar Stenmark och Linda Haglund flankerar vinnarna Pershing och Berndt Lindstedt i första upplagan av Olympiatravet. Foto Stefan Melander/Stalltz.se</figcaption></figure>



<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 Meadow Road. Samma år vann han också Elitloppet och båda avdelningarna i Statue of Liberty Trot.</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>



<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>San Moteur</strong> (e. Panne de Moteur) ut förra året.</p>



<p class="wp-block-paragraph">San Moteur satsade mot Frankrike förra vintern, men skadades och opererades för en griffelbensfraktur strax före Prix d’Amérique. Efter rehab och avelsarbete är fjolårsvinanren i full gång med träning, men årsdebuten dröjer ett tag till. Därmed går han miste om att göra trion Queen L, Copiad och Gidde Palema sällskap. De är nämligen ensamma om att försvara titeln i Olympia- och Paralympiatravet.</p>



<p class="wp-block-paragraph"><strong>Maharajah</strong> (e. Viking Kronos) och sonen <strong>Who’s Who</strong> är ändå 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="has-text-align-center wp-block-paragraph">***</p>



<p class="has-drop-cap wp-block-paragraph">Daniel Redén har en tränarseger i loppet, då norske <strong>Lionel</strong> (e. Look de Star) segrade 2017. Nu mönstrar han sexårige <strong>Kentucky River</strong> (e. Father Patrick), som anslöt till stallet i början av september förra året efter att ha tränats av först Conrad Lugauer och sedan Per Nordström. Hästens främsta merit är andraplatsen i Harper Hanovers lopp förra året.</p>



<p class="wp-block-paragraph">I vinter testades han i två starter på Vincennes och efter hemkomsten var han tvåa i gulddivisionen på Romme i påskas, innan han segrade i Paralympiatravets uttagning på Bergsåker.<br>– Han var jättebra på Bergsåker och jag hoppas att han har gått framåt ytterligare. Spår nio behöver inte vara fel, han känns mer och mer trygg i sig själv och är ingen blixt från start. Han har även snabba ryggar så han behöver inte hamna alltför långt bak. Det kanske även blir lite körning vilket skulle gynna. Han kommer spurta bra i alla fall och det blir jäkligt spännande, säger Daniel Redén på Stall Zets 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/2023/08/castorthestarmed-617x333.jpg" alt="" class="wp-image-478932"/><figcaption class="wp-element-caption">Castor the Star vid segern i bronsdivisionens final under Elitloppshelgen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Kentucky River är tillsammans med Jörgen Westholms <strong>Castor the Star</strong> (e. Maharajah) yngst i finalfältet med sina sex år. Castor the Star kvalade in till både Svenskt Travderby (oplacerad) och Breeders Crown (fyra) som fyraåring, men fick sitt stora genombrott förra året.<br>Då rusade han genom klasserna hela vägen till gulddivisionen efter att ha vunnit bronsfinal i maj och silverfinal i oktober.</p>



<p class="wp-block-paragraph">Annars bjöd han på minnesvärt motstånd till självaste <strong>Francesco Zet</strong> (e. Father Patrick) förra våren i Berth Johanssons Memorial på Umåker, där Castor the Star ledde till meterna före mållinjen.</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/2021/05/sugarcanehanoverdef2-617x333.jpg" alt="" class="wp-image-160002"/><figcaption class="wp-element-caption">Sugercane Hanover, Gunnar Eggen och skötaren Morten Waage segerdefilerar efter uppvisningen 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 Callit. 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">Det kan bli norskt även i årets upplaga när de röd-blå-vita färgerna försvaras av Frode Hamres meriterade fransman <strong>Dorgos du Guez</strong> (e. Romcok de Guez), som får Magnus A Djuse i sulkyn. Dorgos du Guez kom till Hamre för ett år sedan från Jean-Michel Bazire, men det dröjde till ett snabblopp på Bjerke för knappt två veckor sedan innan han gjorde debut i nya regin. Då slutade han trea i loppet som vanns av Håkan K Perssons <strong>Four Guys Dream</strong> (e. Dream Vacation).</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/2021/05/usaintoll1-617x333.jpg" alt="" class="wp-image-169991"/><figcaption class="wp-element-caption">Christian Cracchiolo kuskade bakom Usain Töll som tog sig förbi Dark Roadster på topptiden 1.09,8a/1.640 meter i Ungdomseliten 2021. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">Sju av tio höstar är svenskfödda och av de utländska bidragen består förutom Bengurion Jet och Dorgos de Guez även av nederländske <strong>King Schermer</strong> (e. Trixton). Denne var sexa i parakvalet på Jägersro och hästens främsta merit så här långt är andraplatser i Malmö Stads Pris bakom <strong>Millmighty</strong> förra året. Dessutom var han 2021 tvåa i Ina Scots Ära på Mantorp, ett lopp som vanns av en viss <strong>Önas Prince</strong>.</p>



<p class="wp-block-paragraph">Utländsk touch är det även när det gäller svenskfödde <strong>Usain Töll</strong> (e. Googoo Gaagaa), som tränas av Vitale Ciotola. Usain Töll visade toppform när han plockade hem Grupp II-löpningen Prix Kerjacques (€120.000) på Vincennes i början av april.<br>Tidigare har Usain Töll vunnit Prix General du Pommeau (€50.000) och Prix Jean-Rene Gougeon (€90.000) på Vincennes. Bland Usain Tölls segrar ska också Grupp I-vinsten i Gran Premio Duomo i Florens nämnas.<br>Titelförsvararen Björn Goop, med tre kusksegrar i loppet, kör den svenskfödde travaren.</p>



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



<p class="has-text-align-left wp-block-paragraph"><strong>Hemmahoppet i årets Paralympiatrav är Christoffer Erikssons fux Rackham (e. Love You). Han var med redan förra året och tog då tredjeplatsen i finalen. Den gången som Jägersrohäst – numera är det ju Åby som gäller. Platsen i Paralympiatravet förra året tog han av egen kraft genom att vinna det första uttagningsloppet, Algot Scotts Minne på Åby. Det är faktiskt Rackhams senaste seger. Han kommer ut i finalen med 16 segerlösa starter och är inbjuden till årets lopp.</strong></p>



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



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



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



<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>
