
<p class="has-drop-cap">1 Marcus Melander har kopplat greppet bland de blågula tränarna på andra sidan Atlanten och har gått upp i topp i svensktoppen med 5.932.091 dollar och har passerat <strong>Per Engblom </strong>med 285.573 dollar per den 31 augusti.</p>



<p>Per Engblom är tvåa med 5,6 miljoner dollar och tredjeplatsen håller Åke Svanstedt. Den som lyft sig allra mest under senaste månaden är Petter Engblom – från tolfte- till sjätteplats – efter ha fått ta över flera hästar från broder Pers stall.</p>



<h2 class="wp-block-heading">Svensktoppen i Nordamerika 2026</h2>



<p><strong>Tränare (juli) – Resultat – Dollar</strong></p>



<ol class="wp-block-list">
<li><strong>Marcus Melander</strong> (2) – 452 st: 121-74-74 – $5.932.091</li>



<li><strong>Per Engblom</strong> (1) – 1.245 st: 275-185-151 – $5.646.518</li>



<li><strong>Åke Svanstedt</strong> (3) – 379 st: 78-52-55 – $2.763.795</li>



<li><strong>Nancy Takter</strong> (4) – 266 st: 57-45-28 – $1.760.244</li>



<li><strong>Anette Lorentzon </strong>(5) – 345 st: 69-61-37 – $1.404.027</li>



<li><strong>Petter Engblom </strong>(12) – 199 st: 29-44-23 – $959.482</li>



<li><strong>Lucas Wallin </strong>(7) – 77 st: 18-15-9 – $657.556</li>



<li><strong>Jenny Melander</strong> (6) – 127 st: 22-21-17 – $313.771</li>



<li><strong>Jonas Czernyson </strong>(8) – 96 st: 11-11-14 – $251.629</li>



<li><strong>Michelle Crawford </strong>(9) – 144 st: 15-19-16 – $173.493</li>



<li><strong>Susanne Kerwood </strong>(10) – 83 st: 14-14-12 – $160.658</li>



<li><strong>Jim Oscarsson </strong>(14) – 48 st: 3-10-2 – $138.224</li>



<li><strong>Jenny Bier</strong> (11) – 52 st: 10-7-6 – $101.599</li>



<li><strong>Marielle Enberg</strong> (13) – 36 st: 3-2-1 – $20.577</li>
</ol>



<p><strong>Fotnot:</strong> siffrorna gäller per den 31 augusti.</p>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/06/introuoadam.jpg" alt="" class="wp-image-867023"/><figcaption class="wp-element-caption">Björn Röcklinger-tränade Intro och Ulf Ohlsson. Foto Adam Ström/Stalltz.se</figcaption></figure>



<p class="has-drop-cap">2 En liten försmak av höstens största uppgifter för de treåriga varmbloden bjuds på <strong>Solvalla</strong> (första start 18.40) ikväll med dubbla välbetalda lopp för 2023-kullen.</p>



<p>Solvallas Kriterieserie byggdes 2023 ut med Höstfavoriten i två klasser, för hingstar/valacker respektive ston, som ytterligare ett större lopp i förberedelserna inför uttagningsloppen till banans flaggskepp för treåringarna, Kriteriet och Oaks. Försöken till dessa lopp avgörs på Solvalla söndagen den 27 september, medan finalerna körs 13 dagar senare, den 10 oktober.</p>



<p>De mest meriterade treåringarna hittills saknas i startlistorna, men här finns ändå fyra av sommarens E3-finalister.</p>



<p>Björn Röcklingers<strong> Intro</strong> (e. Readly Express) tillhörde de mest betrodda i långa E3-finalen för hingstar/valacker, men kom aldrig in i loppet från köposition. Att formen sitter där visade han i senaste starten när han vann lätt i Gävle efter att ha körts till ledning mitt i loppet.</p>



<p>Övriga med E3-finalmeriter är roger Walmanns Perfect Batch (e. Perfect Spirit), Daniel Wäjerstens Mister Nabab (e. Mister J.P.) samt Jasmine Isings sto Ismenis (e. Calgary Games).</p>



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



<p class="has-drop-cap">3 Solvalla delar expressomgången med <strong>Axevalla</strong> (första start 18.27). Där drar banans höstserie för treåringar igång. Via sex försök under hösten plockas startfältet fram till finalen på Axevalla den 8 december med 60.000 kronor i förstapris.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/fabiofongini-617x444.jpg" alt="" class="wp-image-645495"/><figcaption class="wp-element-caption">Fabio Fongini. Bild: Criterium Sale</figcaption></figure>



<p>Huruvida kvällens favorit dyker upp där återstår att se, men Björn Goop har ett härligt ämne i toppstammade <strong>Fabio Fognini</strong> (e. Walner) som inlett karriären med två raka segrar i sommar. Fabio Fognini är första avkomman till Breeders Crown-vinnaren och Derbystotvåan <strong>Milady Grace</strong> (e. Ready Cash), 1.12,2am*/3.468.000 kr.</p>



<p>Loppet ligger utanför det stora streckspelet, där Axevallas halva ser ut att bjuda på mycket Carl Johan Jepson. Nio gånger de tio senaste åren har Jepson blivit kuskchampion på Skaraslätten och han har redan säkrat titeln även 2026 då han har 22 segrars ledning.</p>



<p>Jepson är klar favorit i tre av Axevallas avdelningar och den gemensamma nämnaren är att Christoffer Eriksson tränar alla: <strong>Hall of Fame S.</strong> (e. Muscle Hill). <strong>Arcania S.</strong> (e. Southwind Frank) och <strong>Grodda Jet </strong>(e. Oasis Bi).</p>



<p>Det är dessutom jackpot på V86-spelet med nästan fem miljoner kronor extra i åttarättspotten.</p>



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



<p><a href="https://sulkysport.se/wp-content/uploads/2026/08/02v86.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/08/02v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/idaodetillard-1-617x333.jpg" alt="" class="wp-image-888327"/><figcaption class="wp-element-caption">Idao de Tillard. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">4 Ett riktigt tungviktsmöte blir det i <strong>La Capelle </strong>idag (första start kl. 13.55) när <strong>Idao de Tillard</strong> (e. Severino) och<strong> Inexess Bleu</strong> (e. Vittel de Brevol) ställs mot varandra i Grand Prix Federation Regionale du Nord (€120.000) över distansen 1.800 meter med autostart.</p>



<p>Tre raka segrar ståtar Idao de Tillard med i Grupp II-löpningarna Prix René Ballière (€200.000), Prix de Washington (€120.000) och Criterium de Basse de Normandie (€120.000), medan Inexess Bleu vann sitt senaste framträdande Prix d’Europe (€150.000) på Enghien.</p>



<p><strong>Grand Prix Federation Regionale du Nord </strong>(€120.000)<br>4-11 år.<br><em>1.800 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Jingle du Pont </strong>(e. Niky) – Nicolas Bazire</li>



<li><strong>Jilord Viva</strong> (e. Vulcain du Viver) – Julien Raffestin</li>



<li><strong>Inexess Bleu </strong>(e. Vittel de Brevol) – Alexandre Abrivard</li>



<li><strong>Idao de Tillard </strong>(e. Severino) – Clément Duvaldestin</li>



<li><strong>Igrec de Celland </strong>(e. Django Riff) – Alexis Collette</li>



<li><strong>Falco Killer Gar</strong> (e. Varenne) – Franck Nivard</li>



<li><strong>Inmarosa </strong>(e. Amiral Sacha) – Leo Abrivard</li>



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



<li><strong>Rikita JP</strong> (e. Mister J.P.) – Corentin Delbecq</li>
</ol>



<p>Flera svenskfödda travare dyker upp La Capelle-banan. Redan i första loppet – Prix du Credit Agricole Nord-Est (€35.000) – jagar  Erik Lindegrens Ruger (e. Readly Express) jagar tredje raka segern. I samma lopp startar Markus B Svedbergs <strong>Comes With Age </strong>(e. Zola Boko) och Jörgen Westholms <strong>Red Hot Roadster</strong> (e. Red Hot Dynamite) över distansen 2.700 meter autostart.</p>



<p>Dubbla hästar har Jörgen Westholm till start i sadelloppet Prix Francois Caille (€35.000) över 2.750 meter. Estelle Croisic rider <strong>Mercenary</strong> (e. Ready Cash) och Mehdi Lelievre sitter upp på<strong> Cameron</strong> (e. Maharajah) i ett lopp där det lockas med 15.750 euro i förstapris.</p>



<p><a href="https://www.letrot.com/courses/programme/2026-09-02/202" data-type="link" data-id="https://www.letrot.com/courses/programme/2026-09-02/202" target="_blank" rel="noreferrer noopener">Startlistorna till tävlingarna hittar du här.</a></p>



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



<p class="has-drop-cap">5 Idag slår Arqana Trot upp portarna för prestigeauktionen Ventes de Yearling Sélectionnés i Deauville och första utrop sker klockan 16.30.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/skarmavbild20260901kl.21.38.34-350x564.jpg" alt="" class="wp-image-893266"/><figcaption class="wp-element-caption">Screenshot</figcaption></figure>



<p>De senaste åren har Deauville arrangerat en internationell auktion, men den ”försvinner” och istället har 28 utlandsfödda ettåringar inkluderats i det ordinarie katalogen, som totalt omfattar 496 hästar.</p>



<p>Bakgrunden är erfarenheterna från de två tidigare upplagorna. Den första hade ett stort utbud, men relativt låg kvalitet och drygt 50 procent av hästarna såldes. Året därpå höjdes kvaliteten samtidigt som utbudet minskades, men försäljningsvolymen förbättrades inte nämnvärt.</p>



<p>Årets katalog håller hög klass och bland annat finns 32 avkommor efter <strong>Face Time Bourbon</strong>, medan <strong>Idao de Tillard</strong> representeras av 21 ettåringar. Den dubble Prix d’Amérique-vinnarens första kull (två år) har redan gjort stort intryck, medan Face Time Bourbon toppar den franska hingststatistiken.</p>



<p>Auktionen genomförs 2–4 september och under öppningsdagen inrymmer katalogen 152 hästar.</p>



<p>Trots ett osäkert ekonomiskt läge inom travsporten är Arqana Trots vd Hugues Rousseau optimistisk inför årets auktion. Han pekar framför allt på att de franska prispengarna är säkrade och bibehålls på nuvarande nivå under de kommande två åren:</p>



<p>– Jag tror inte att det finns någon anledning till oro. Prisnivån på auktionerna kommer åtminstone att vara stabil.</p>



<p>Vid fjolårets auktion presenterades 460 hästar, varav 302 såldes. Totalt såldes det ettårinngar 9,8 miljoner euro. Snittpriset landade på 32.565 euro och medianen på 22.500 euro.</p>



<p><a href="https://www.arqana-trot.com/catalogue/ventes-de-yearlings-2026/236" data-type="link" data-id="https://www.arqana-trot.com/catalogue/ventes-de-yearlings-2026/236" target="_blank" rel="noreferrer noopener">Här hittar du hästarna som bjuds ut i Deauville.</a></p>



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



<p class="has-drop-cap">6 Startfältet till amatör-SM på Åby den 26 september med 150.000 kronor till vinnaren är till två tredjedelar fastställt. Detta sedan Emma Smedeby och <strong>M.Y D.X. One </strong>vunnit gårdagens uttagningslopp i Eskilstuna.</p>



<p>Ikväll fylls det på med ytterligare två ekipage när både Solvalla och Axevalla har varsitt försök.</p>



<h2 class="wp-block-heading">Kuskar klara för Amatör-SM:</h2>



<p><strong>Kusk – Hemmabana</strong></p>



<ul class="wp-block-list">
<li><strong>Mercedes Balogh </strong>– Örebro</li>



<li><strong>Håkan B Johansson</strong> – Halmstad</li>



<li><strong>Hans Bergh</strong> – Bergsåker</li>



<li><strong>Paavo Koivurova</strong> – Boden</li>



<li><strong>Oscar Ginman</strong> – Kalmar</li>



<li><strong>Niclas Benzon </strong>– Årjäng</li>



<li><strong>Arne Ramberg</strong> – Romme</li>



<li><strong>Emma Smedeby</strong>– Eskilstuna</li>
</ul>



<p>Kommande uttagningar till Amatör-SM: <strong>Axevalla/Åby </strong>(Axevalla idag), <strong>Solvalla/Visby</strong> (Solvalla idag), <strong>Bollnäs/Hagmyren</strong> (Bollnäs 11/9), <strong>Dannero/Solänget </strong>(Solänget 14/9).</p>



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



<p class="has-drop-cap">7 Avelshingsten <strong>Idéal du Pommeau</strong> (e. Ready Cash), 1.11,2l/€484.350, vars första kull är född 2024, fick på söndagen sin första vinnare som avelshingst. På banan i Turin i Italien segrade dottern Luxury Gio över 1.600 meter med autostart och segertiden skrevs till 1.15,6. I ett lopp med endast fem ston visade sig Luxury Gio från sin bästa sida efter att ha fått draghjälp under avancemanget på bortre långsidan.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/skarmavbild20260901kl.19.21.28-617x356.jpg" alt="" class="wp-image-893248"/><figcaption class="wp-element-caption">Luxury Gio spurtar till vinst.</figcaption></figure>



<p>Luxury Gio är halvsyster till flerfaldiga Grupp I-vinnaren <strong>Funny Gio</strong> (e. Face Time Bourbon), 1.08,9/€699.224. </p>



<p>Ideal du Pommeau hann inte göra fler än 25 starter i karriären och elva av dem slutade med seger. Största triumfen kom i Europaderbyt 2022 på Vincennes, där han vann på 1.11,5a/2.100 meter. Sista starten gjordes i Lyon i slutet av november ifjol. 71 avkommor finns registrerade i hingstens kull född 2024.</p>
