
<p class="has-drop-cap wp-block-paragraph">1Hela 300.000 kronor väntar vinnaren i kvällens auktionslopp på Åby. Loppet är öppet för tvååriga hästar som såldes eller ropades åter och som har betalt insatserna därtill på Sweden International Yearling Sales ettåringsauktioner på Solvalla och Åby under 2025.</p>



<p class="wp-block-paragraph">Mest meriterad är Fredrik Wallin-tränade stoet <strong>Pure Enya</strong> (e. Maharajah), som travat ihop 112.000 kronor på tre starter, vilka resulterat i två andraplatser och ett tredjepris.<br>En obesegrad tvååring finns bland de anmälda, Claes Sjöström-tränade <strong>Rocksteady Artist</strong> (e. Captain Corey) som blev drömmilare redan i livets första start när han vann på 1.14,6a/1.640 meter på Solvalla.</p>



<p class="wp-block-paragraph"><strong>Så mycket kostade hästarna på auktion:</strong><br><em>Häst (far) – Auktion – Pris</em></p>



<ul class="wp-block-list">
<li><strong>Wonderful Tile</strong> (e. Walner) – Åby – 600.000 kr</li>



<li><strong>Overlord Sisu</strong> (e. Captain Corey) – Solvalla – 550.000 kr</li>



<li><strong>Bearnando</strong> (e. Readly Express) – Åby – 360.000 kr</li>



<li><strong>Rocksteady Artist</strong> (e. Captain Corey) – Solvalla – 280.000 kr</li>



<li><strong>Soran Boko</strong> (e. Italiano Vero) – Solvalla – 240.000 kr</li>



<li><strong>Pure Island</strong> (e. Ecurie D.) – Criterium Sale – 130.000 kr</li>



<li><strong>Pure Enya</strong> (e. Maharajah) – Solvalla – 90.000 kr</li>
</ul>



<p class="wp-block-paragraph">Auktionsloppet ligger utanför kvällens V86-kupong och det gäller även ungdomsloppet till Olle Goops Minne. Det är öppet för kuskar födda 2001 eller senare och avgörs för tredje gången på Åby. Jonas M Oscarsson och Alex Persson har vunnit de föregående upplagorna och den sistnäömnde finns med även i år, där han kör André Eklundh-tränade <strong>Mo Salah</strong> (e. Donato Hanover).</p>



<p class="wp-block-paragraph">Olle Goop gick bort den 20 april 2022 och Olle var – bland mycket, mycket annat – champion på Åby 26 år i följd, åren 1973-1998.</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/09/barnbank-617x333.jpg" alt="" class="wp-image-901472"/><figcaption class="wp-element-caption">Timo Nurmos-tränade Barn Bank och Magnus A Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Kvällens expresstrav med V86 delas av Solvalla (första start 18.15) och Åby (första start 18.27).</p>



<p class="wp-block-paragraph"><strong>Barn Bank</strong> (e. Face Time Bourbon) visade hög kapacitet i sina få starter som treåring för Timo Nurmos, men fick inte till det när det väl gällde. I Kriteriekvalet blev han alldeles för het i ledningen efter en bit och missade finalen som fyra och i Breeders Crown-semifinalen galopperade han bort en klar andraplats mitt på upploppet.<br>I år har han ännu inte startat – struken för sårskada från den tänkta årsdebuten i juni – men nu görs ett nytt försök efter nästan elva månaders uppehåll. Innerspår bakom bilen i ett försök i Solvallaserien är uppgiften.</p>



<p class="wp-block-paragraph">Åbys snabblopp The Red Mile – över den engelska milen 1.609 meter – har körts sedan början av 1980-talet och två gånger har det krävts en tid under 1.10 för att vinna. Först ut var italienske <strong>Propo O.P.</strong> som vann på 1.09,9a 2018 och ifjol var det dags igen när <strong>Karat River</strong> sänkte löpningsrekordet till 1.09,8a tillsammans med sin tränare Johan Untersteiner.<br>I årets upplaga gör dubbelmiljonären <strong>Ture L.A.</strong> (e. Maharajah) comeback efter sju månaders tävlingsfrånvaro. Dessutom sker det i ny regi när Mantorpamatören Liselott Stenström sedan i mars tränar nioåringen. Liselott är delägare och uppfödare till Ture L.A.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/23v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar.</a></p>



<p class="wp-block-paragraph"><strong>Sulkysports expertpanel levererar sina bästa spikar och roliga skrällar till kvällens V86-omgång vid lunchtid idag.</strong></p>



<p class="wp-block-paragraph"><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/simsalabim/V86_2026-09-23_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Simsalabim.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/69ansspel/V86_2026-09-23_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos 69:ans Spel &#038; Tobak.</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/spelpoolen/V86_2026-09-23_40_1" target="_blank" rel="noreferrer noopener">Här finns andelar till V86 hos Spelpoolen.</a></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/11/skarmavbild20251109kl.17.21.32-617x383.jpg" alt="" class="wp-image-791061"/><figcaption class="wp-element-caption">Birger Jörgensen och Menza vid segern i Dansk Uppfödningslöpning ifjol på Charlottenlund.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3På söndag är det dags för Krieteriekval för de svenskfödda treåringarna, men redan ikväll är det upp till bevis för ungdomarna i Danmark med uttagningslopp på Charlottenlund och en hel del svensktränat i startlistorna.</p>



<p class="wp-block-paragraph">Det stora namnet i 2023-kullen är dansktränad, hingsten <strong>Menza</strong> (e. Readly Express), som inledde karriären med 13 raka segrar, innan han gick på pumpen under Derbyhelgen i slutet av augusti. Efter att ha suttit fast och fått backa sig kom Menza aldrig in i matchen, samtidigt som han inte hade sin bästa dag när <strong>Malthe S.H.</strong> (e. Calgary Games) bröt hästens långa segerrad.<br>– Menza blev fast invändigt senast och var kanske inte riktigt på topp den dagen. Han såg lite oengagerad och oinspirerad ut och skiftade en del i travet, vilket inte är likt honom. Några dagar efter senaste starten undersöktes han av veterinär och behandlades i ett framknä och en bakkota. Han är i gång med träningen igen och känns fin och redo. Jag har en bra känsla för Menza. I fredags gick han ett riktigt fint jobb och jag är väldigt optimistisk, säger Gordon Dahl om sitt stora ämne på ATG:s hemsida.</p>



<p class="wp-block-paragraph">Åtta av 24 hästar i Kriteriekvalen är svensktränade. Kim Pedersens duo <strong>Marius May</strong> (e. Great Challenger) och <strong>Made By Nordic</strong> (e. Bold Eagle) har båda hamnat i Menzas försök.</p>



<p class="wp-block-paragraph">Johan Untersteiner, som tränar årets vinnare i danska Derbyt Lazy Dust, testar med <strong>Mill Iwujii</strong> (e. Calgary Games), som bland annat ställs mot Ken Ecces <strong>Morningstar Derm</strong> (e. Nuncio).<br>Fyra av åtta hästar i det sista försöket reser från Sverige: Håkan K Perssons <strong>Magic John</strong> (e. Bird Parker), Jimmi Ehlers <strong>Meslois</strong> (e. Southwind Frank), Daniel Redén-tränade <strong>Maigaardlovescosta</strong> (e. Readly Express), samt <strong>Magic Park</strong> (e. Father Patrick) från Per Nordströms stall.</p>



<p class="wp-block-paragraph">På stosidan blir det fyra uttagningslopp till Stokriteriet och de tre främsta i varje kniper finalplatser. Två svensktränade hästar startar och Kim Pedersens <strong>Morag</strong> (e. Chocolatier) ocn Ken Ecces <strong>Mamacita D.K.</strong> (e. Propulsion) möts i ett tufft försök med vassa motståndare som <strong>Magda</strong> (e. Quick Wood) och <strong>Merle</strong> (e. Wishing Stone). </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/23lunden.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till de danska Derbykvalen.</a></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/11/oppgardsdrangen-617x333.jpg" alt="" class="wp-image-790731"/><figcaption class="wp-element-caption">Oppgårdsdrängen och Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Han var knappt slagen tvåa i svenska Derbyt bakom Tangen Bork som unghäst och har under flera säsonger tillhört Sveriges bästa äldre hästar med toppåret 2025 då han vann åtta lopp och sprang in 1,1 miljoner kronor.<br>Nu är <strong>Oppgårdsdrängen</strong> (e. Tekno Odin-Oppgårdens Smaragd), 1.20,2ak*/3.745.326 kr, en vinnare på annat sätt – som pappa!</p>



<p class="wp-block-paragraph">Som femåring fick Oppgårdsdrängen smygstarta i avelsboxen och resultatet blev fyra avkommor födda 2023. I Bollnäs i måndags var det dags att spräcka segernollan för fadern när Oskar Kylin Blom-tränade <strong>Drängens Trolle</strong> slog till och vann Sleipner Bollnäs Månadstäcke och 35.000 kronor tillsammans med Ulf Ohlsson på nya rekordet 1.30,3/2.140 meter.</p>



<p class="wp-block-paragraph">Drängens Trolle har tidigare varit tvåa och trea som bäst på sju försök och på priskontot finns nu 80.400 kronor. Även stoet <strong>Nyboda Ida</strong>, 1.31,4am/81.000 kr, har tävlat i år som treåring.</p>



<p class="wp-block-paragraph">Oppgårdsdrängen är uppfödd och ägd av Ingegerd Jansson, Edsbro.</p>



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



<p class="has-drop-cap wp-block-paragraph">5Det drar ihop sig för final i årslånga, franska löpningsserien Grand National du Trot, vars höjdpunkt kommer på Vincennes den 6 december. Fortfarande finns dock fyra chanser att säkra en plats i den stora finalen och den första redan idag.</p>



<p class="wp-block-paragraph">Det tionde försöket avgörs över 2.875 meter i Argentan med 90.000 euro i potten och 18 hästar på tre volter.<br>Bland dessa finns två hästar som redan bockat av en försöksseger i årets GNTY-serie. <strong>Jentil Dieschoot </strong>(e. Un Charme Fou) slog till redan i det första i början av mars, medan <strong>Jeannette Priory</strong> (e. Tag Wood) vann för två veckor sedan i det senaste försöket.<br>Flera starta kort finns på mellanvolten, som just Jeannette Priory och Thierry Duvaldestin-tränade <strong>Just de l’Oison</strong> (e. Quaro). Den sistnämnde ståtar med tre raka segrar.</p>



<p class="wp-block-paragraph"><strong>Startlista Grand National du Trot (€90.000)</strong><br>2.875 meter, Argentan onsdag<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Koves du Pont (e. Quinoa du Gers) – Nicolas Bazire</li>



<li>Humour Festif (e. Prodigious) – Jerome Johnny Baillon</li>



<li>Jain Mab (e. Ni Ho Ped d’Ombree) – Anthony Barrier</li>



<li>Jack The Ass (e. Alberic( – Mathieu Mottier</li>



<li>Jentil Dieschoot (e. Un Charme Fou) – Alexandre Abrivard</li>



<li>Karnac Wood (e. Ready Cash) – Hugues Monthule</li>



<li>Lord Delo (e. Face Time Bourbon) – Thomas Beauchene</li>



<li>Lipet de Crepin (e. Boccador de Simm) – Sebastien Ernault</li>



<li>Little Brown (e. Goetmals Wood) – David Thomain</li>



<li>Jolivert du Gers (e. Bold Eagle) – Matthieu Abrivard</li>



<li>Hescort Love (e. Vivaldo Bello) – Maxime Grasset <br><strong>2.900 meter:</strong></li>



<li>Jeannette Priory (e. Tag Wood) – Tony Le Beller</li>



<li>Just de l’Oison (e. Quaro) – Theo Duvaldestin</li>



<li>Indus Val (e. Booster Winner) – Pierre Yves Verva</li>



<li>Ialto d’Hertals (e. Alto de Viette) – Clement Duvaldestin</li>



<li>Harmonista (e. Vulcain de Vandel) – Franck Nivard</li>



<li>Jazzman Debailleul (e. Repeat Love) – Antoine Lherete <br><strong>2.925 meter:</strong></li>



<li>Hulysse Digeo (e. Reve de Beylev) – Jean William Hallais</li>
</ol>



<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/02/tretiakmadm250208adamstromstalltz-617x422.jpg" alt="" class="wp-image-685799"/><figcaption class="wp-element-caption">Tretiak och Magnus A Djuse. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Det är minst sagt svensktätt i avslutningsloppet Prix Paris Turf x PMU (€30.000) över 2.875 meter i Argentan. Sex av hästarna ägs av svenskar, fem av dem är svenskfödda och tre tränas dessutom av svenskar.<br>Markus B Svedberg står bakom två av dem i <strong>Xhantis Ibiza</strong> (e. International Moni) på startfållan och <strong>Comes With Age</strong> (e. Zola Boko) från tillägg.</p>



<p class="wp-block-paragraph">Maria Törnqvist har ett lysande facit i Frankrike i år med 13 segrar på 33 starter, den senaste med <strong>Jackpot Mearas</strong> (e. Muscle Hill) på Vincennes i fredags. Nu mönstrar hon Frankrikedebutanten <strong>Tretiak</strong> (e. Bold Eagle), som gjort tre starter hos Törnqvist efter långt uppehåll och tränarbyte, men inte fått till det. Hästen tog innan dess nio segrar på tolv starter hos Mattias Djuse, den senaste i mars förra året.</p>



<p class="wp-block-paragraph">Svenskägda i loppet är även Erik Bondos duo <strong>Jacques Mearas</strong> (e. Ready Cash) och <strong>Destino D.J. </strong>(e. Wishing Stone), liksom <strong>Trixwithtrimmix</strong> (e. Trixton) i träning hos  Hendrik Dragt.</p>



<p class="wp-block-paragraph">Juhani Partanens elvaåring <strong>Västerbo Imtheman</strong> (e. Echo) har har rest tillbaka till Frankrike under sensommaren och tränas av Jean Benoit Lemoine. Nu görs fjärde starten efter återkomsten när han kommer ut i ett montélopp med 53.000 euro i total prissumma, varav vinnaren får 23.850. Han kommer närmast från en sjätteplats under sadel i Angers.</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2026-09-23/6102" target="_blank" rel="noreferrer noopener">Här är startlistorna till tävlingarna i Argentan.</a></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/05/13goldenboy-617x333.jpg" alt="" class="wp-image-856602"/><figcaption class="wp-element-caption">1.08,8a/1.609 meter skrevs segertiden till för Alessandro Gocciadoro-tränade Golden Boy och Antonio di Nardo i Fyraåringseliten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">7Det femte och sista uttagningsloppet till Grand Prix de l’U.E.T. körs i Turin på söndag, men intresset för att kvala in till finalen som går på samma bana var svalt.</p>



<p class="wp-block-paragraph">Endast sex hästar finns med bakom bilen i Turin och Alessandro Gocciadoro tränar tre av dem. Själv sitter han upp bakom <strong>Guglielmo Jet</strong> (e. Maharajah), medan Antonio Di Nardo är uppsatt bakom <strong>Golden Boy</strong> (e. Maharajah) – vinnare av Fyraåringseliten och trea i Sprintermästaren i år – och Federico Esposito kör <strong>Glorious Gio</strong> (e. Face Time Bourbon).</p>



<p class="wp-block-paragraph"><strong>Startlista uttagningslopp till Grand Prix de l’U.E.T. (€30.000)</strong>, <strong>Turin</strong><br><em>Häst (far) – Tränare</em></p>



<ol class="wp-block-list">
<li>Glorious Gio (e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li>Golden Boy (e. Maharajah) – Alessandro Gocciadoro</li>



<li>Gulp Slf (e. Love You) – Erik Bondo</li>



<li>Gaber Gio (e. Face Time Bourbon) – Harri Rantanen</li>



<li>Ginger Gio (e. Tony Gio) – Sébastien Guarato</li>



<li>Guglielmo Jet (e. Maharajah) – Alessandro Gocciadoro</li>
</ol>



<p class="wp-block-paragraph">På fredag körs två uttagningslopp till Europaderbyt på Vincennes och dagen därpå ska två lopp avverkas på Åby.</p>



<p class="wp-block-paragraph"><strong>Försök 1, Europaderbyt, Vincennes</strong><br>2.100 m autostart<br><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li>Montequillo (e. Royal Dream) – Jean-Philippe Dubois</li>



<li>Miss Matters (e. Ready Cash) – Alexandre Abrivard</li>



<li>Manaslu (e. Love You) – Yoann Lebourgeois</li>



<li>Magic Night (e. Hegafell) – Benjamin Rochard</li>



<li>Must Atout (e. Face Time Bourbon) – Alexis Collette</li>



<li>My Qualita Piya (e. Goetmals Wood) – Franck Nivard</li>



<li>Mostra de Banville (e. Hohneck) – Clément Duvaldestin</li>



<li>Maestro Vrie (e. Village Mystic) – Mathieu Mottier</li>
</ol>



<p class="wp-block-paragraph"><strong>Försök 2, Europaderbyt, Vincennes</strong><br>2.100 m autostart<br><em>Häst (far) – Körsven</em></p>



<ol class="wp-block-list">
<li>Golden Gio (e. Face Time Bourbon) – Eric Raffin</li>



<li>Monzon Normand (e. Hohneck) – Paul-Philippe Ploquin</li>



<li>Fragolino Rosso (e. Booster Winner) – Robin Bakker</li>



<li>Mack de Blary (e. Face Time Bourbon) – Théo Duvaldestin</li>



<li>Maharaja Atout (e. Ready Cash) – David Thomain</li>



<li>Magnum du Choquel (e. Hohneck) – Francois Lagadeuc</li>



<li>Mindfreak (e. Go On Boy) – Romain Derieux</li>
</ol>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/26v85.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till försöken på Åby.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Priserna för auktionshästarna
Tvååringar tävlar om 300.000 kronor i auktionslopp. Nurmos-ämne tillbaka efter elva månader. En tredjedel svensktränat i danska Kriteriekval. ”Drängens” första seger som pappa. Svensktätt i Argentan. De kvalar till Europaderbyt.
Detta och mer bland onsdagens nyheter.
Detta och mer bland onsdagens nyheter.
