
<p class="has-drop-cap wp-block-paragraph">1Det inleddes för att fira på Färjestad 24 september 2005 för att fira 100-årsjubileumet av Unionsupplösningen mellan Sverige och Norge 1905. Tävlingsdagen på Färjestad (första start 13.30) har setts som en match mellan de båda grannländerna och den svenska överlägsenheten har varit stor under de 20 gånger som tävlingsdagen genomförts.</p>



<p class="wp-block-paragraph">Statistiken visar att av de 243 lopp som körts under tävlingsdagen har 181 vunnits av hästar tränade av svenskar, medan norska tränare fått nöja sig med 55 segrar. Resterande sju lopp har gått till tränare från andra länder.</p>



<p class="wp-block-paragraph">I eftermiddag är det dags igen och i dagens åtta lopp på V85-kupongen är sex förhandsfavoriter svensktränade. Bland de många svensktränade hästarna är Daniel Redén-tränade <strong>Bright Star U.S.</strong> (e. Muscle Hill) är favorit i gulddivisiosnen – Uno Sweds Minneslopp. </p>



<p class="wp-block-paragraph">Sweds största stjärna var <strong>Madison Avenue</strong> – själv flerfaldig storloppsvinnare och dessutom pappa till Elitloppsvinnaren <strong>Meadow Road</strong> – men Uno som gick under namnet travets hedersman kunde vinna med allt. Sju år på 1960-talet blev han segerrikaste kusk i Sverige! </p>



<p class="wp-block-paragraph">Femårige Bright Star U.S. har vunnit två lopp på sju försök i år, däribland femårimngsloppet Henning Mårthans Minne i Rättvik. </p>



<p class="wp-block-paragraph">– Bright Star U.S. hade en omöjlig uppgift senast och blev dessutom fimpad i sista sväng, men han travade bra i svängarna och Örjan var väldigt nöjd med hur han kändes och därför får han starta tätt. Allt ser bra ut och spåret passar då han kan öppna bra bakom bilen, säger Daniel Redén på sin hemsida <a href="http://reddis.se" target="_blank" rel="noreferrer noopener">reddis.se</a>.</p>



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



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/08/bjorngoop.jpg" alt="" class="wp-image-888321"/><figcaption class="wp-element-caption">Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Norrmännen spelar allt som oftast direkt in i den svenska poolen för lördagens huvudspel och Unionstravet på Färjestad hör till de mest intressanta för våra grannar. Förra året stannade V75-omsättningen vid 89.917.407 kronor, vilket var den näst lägsta noteringen i Unionstravets historia.</p>



<p class="wp-block-paragraph">Idag handlar det om en av de sista omgångarna med V85-spel innan V75 gör comeback i slutet av november, där största skillnaden blir förhöjt radpris till 60 öre.</p>



<p class="wp-block-paragraph">Sulkysports expertpanel har plockat fram sina bästa spikförslag och skrällarna som du inte får missa på Färjestad idag. Ett av enkelstrecken är hemmatränaren Björn Goops norskfödde femåring <strong>Mohawk</strong> (e. Maharajah), som är obesegrad i tre starter sedan han anlände till Goops stall från Norge.<br>– Mohawk har gått jättebra och är fortsatt fin. Vi har testat rycktussar och det funkade bra hemma. Spår två är bra, han går bra bakifrån och i ledningen och är inte beroende av löpningen. Han har gjort det på bra sätt hittills, säger Björn Goop. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-tips-f-19-sep/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Färjestads V85-omgång.</a></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/V85_2026-09-19_15_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



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



<p class="wp-block-paragraph"><a href="https://www.atg.se/butik/spelpoolen/V85_2026-09-19_15_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



<p class="wp-block-paragraph">Den svenska travlördagen drar igång redan på förmiddagen med breddloppstävlingar på två banor: Östersund (första start 11.00) och Halmstad (första start 11.10).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/260919.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</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/07/goonboy2026-617x333.jpg" alt="" class="wp-image-874381"/><figcaption class="wp-element-caption">Go On Boy och Romain Derieux. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">3Forne Elitloppsvinnaren <strong>Go On Boy </strong>(e. Password) vann det belgiska storloppet Grand Prix de Wallonie (€150.000) i Mons både 2023 och 2024. Förra året gick segern till <strong>Inexess Blue </strong>(e. Vittel de Brevol). När det i eftermiddag är dags för årets upplaga möts de två mångmiljonärerna i kamp om 72.000 euro i förstapris!<br>Det är också sista loppet i UET Elite Circuit, där Inexess Bleu vann finalen på Solvalla förra året. För att vara på säkra sidan för att få vara med i årets final i Turin den 11 oktober krävs seger eller andraplats.</p>



<p class="wp-block-paragraph">Det loppet är redan inskrivet i matchningsplanen för Go On Boys tränare och kusk Romain Derieux att vara med.<br>– Min häst är tio år gammal, men jag tycker fortfarande han är i fin form. Han är full av energi. Vi skulle gynnas av ett rygglopp i högt tempo, men Go On Boy kan allt och har vunnit det här loppet från ledningen. Inexess Bleu verkar vara hästen att slå, men vi åker inte tillMons för att bli sexa, säger Romain Derieux.</p>



<p class="wp-block-paragraph">En intressant comeback gör <strong>Frank Gio</strong> (e. Face Time Bourbon) och han har inte varit synlig på tävlingsbanan sedan fjärdeplatsen i Prix de l’Atlantique i mitten på april.</p>



<p class="wp-block-paragraph"><strong>Grand Prix de Wallonie (€150.000)</strong><br>2.480 meter autostart.<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Harley Gema</strong> (e. Bold Eagle) – Alan Gendrot</li>



<li><strong>Frank Gio</strong> (e. Face Time Bourbon) – Matthieu Abrivard</li>



<li><strong>Keep Going</strong> (e. Follow You) – Mathieu Mottier</li>



<li><strong>Krack Time Atout</strong> (e. Face Time Bourbon) – Franck Nivard</li>



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



<li><strong>Go On Boy</strong> (e. Password) – Romain Derieux</li>



<li><strong>Cobra Killer Gar</strong> (e. Readly Express) – Gabriele Gelormini</li>



<li><strong>Cicero Noa</strong> (e. Mandarino Blue) – Francis Neirinck</li>



<li><strong>Jingle du Pont</strong> (e. Niky) – Nicolas Bazire</li>



<li><strong>Falco Killer Gar</strong> (e. Varenne) – Jules van den Putte</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">4Det tävlas på sex franska banor idag och flera hästar med blågult intresse finns på tre av banorna.</p>



<p class="wp-block-paragraph">Fredrik Wallin plockar ut <strong>Västerbo Blizzard</strong> (e. El Mago Pellini) i ett montélopp i Pornichet med 30.000 euro i potten, varav vinnaren får 13.500 euro. Eric Raffin sitter upp i sadeln och gör tredje starten på fransk mark. En tredjeplats har det blivit som bäst hittills när Västerbo Blizzard nu gör montédebut i Frankrike. På svensk mark har det blivit tre segrar på åtta starter.<br>Svenskägde och -födde <strong>M.T. Ramos</strong> (e. Quite Easy) finns bland motståndarna.</p>



<p class="wp-block-paragraph">Alf Nordemo-ägda, svenskfödda duon <strong>Byron Face</strong> (e. Raja Mirchi) och <strong>Bottnas Justin</strong> (e. Brillantissime) möts i Europaloppet i Hyeres med 9.450 euro i förstapris. 2.850 meter är distansen och i vagnarna bakom hästarna sitter Pierre Vercruysse respektive Yannick Alain Briand. Även svenskfödde <strong>Nobby Stiles Boko</strong> (e. Coin Perdu) finns med i loppet.</p>



<p class="wp-block-paragraph">Kvällens svenska bidrag är Jarmo Niskanen-tränade <strong>Monogame</strong> (e. Uniclove) i ett lopp med 15.000 euro i total prispott i Amiens.</p>



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



<p class="has-drop-cap wp-block-paragraph">5I eftermiddag avgörs Villinmiehen Tammakilvan (€84.800), eller finska varianten av Stochampionatet, i Lappeenranta med 40.000 euro i förstapris.</p>



<p class="wp-block-paragraph">En svensktränad häst finns bland de tolv finalisterna, Umåker-tränaren Jonna Irris sto <strong>Margaritaz</strong> (e. Readly Express), som var tvåa i sitt försök. Hästen har vunnit fem gånger på 17 försök.<br>Catchdrivern Mika Forss deläger och kör sitt sto <strong>Rich Shade</strong> (e. Victor Gio), som tillhör favoritskaran som en av fyra försöksvinnare. </p>



<p class="wp-block-paragraph"><strong>Startlista Villinmiehen Tammakilvan (€84.800)</strong><br>2.100 meter autostart, Lappeenranta<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Sister Serene</strong> (e. Father Patrick) – Hannu Torvinen</li>



<li><strong>Rich Shade</strong> (e. Victor Gio) – Mika Forss</li>



<li><strong>Lykke Li Hoss</strong> (e. Maharajah) – Santtu Raitala</li>



<li><strong>Margaritaz</strong> (e. Readly Express) – Olli Koivunen</li>



<li><strong>Shackhills Grace</strong> (e. Fabulous Wood) – Tuukka Varis</li>



<li><strong>Silver Stahl</strong> (e. Maharajah) – Tommi Kylliäinen</li>



<li><strong>Spring Ale</strong> (e. Maharaja) – Pekka Korpi</li>



<li><strong>Mas Josefina</strong> (e. Cantab Fashion) – Esa Holopainen</li>



<li><strong>Emiliana</strong> (e. Sahara Dynamite) – Ari Moilanen</li>



<li><strong>Orquidea</strong> (e. Orlando Vici) – Kari Venäläinen</li>



<li><strong>Margarita Frido</strong> (e. Maharajah) – Jukka Torvinen</li>



<li><strong>Flory Combo</strong> (e. Diamond Duo) – Sari Vesala</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/2017/05/sauveurml-617x288.jpg" alt="" class="wp-image-7033"/><figcaption class="wp-element-caption">Sauveur. Foto Mia Törnberg</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Hela 55 hästar bjuds ut till försäljning på kvällens internetauktion hos Travera och det är bred spännvidd från ettåringar till avelshingstar.</p>



<p class="wp-block-paragraph">I den sistnämnda kategorien finns två hästar, svenskfödde <strong>Sauveur</strong> (e. Echo), 1.11,0am/5.571.965 kr, och USA-födde <strong>Toast of Lindy</strong> (e. Cantab Hall), 1.10,6ak/€160.027.<br>16-årige Sauveur vann Norrbottens Stora Pris och Harper Hanovers lopp och har 33 svenskfödda avkommor med 1.11-travaren Lucky Lane i topp. Elvaårige Toast of Lindy köptes från USA till Finland, där han fått 37 avkommor.</p>



<p class="wp-block-paragraph">Lutfi Kolgjini har sju ettåringar från sin uppfödning ute för försäljning med fäder som Father Patrick, Francesco Zet, Propulsion och Bold Eagle.</p>



<p class="wp-block-paragraph"><a href="https://www.travera.nu/kopa-hast/" target="_blank" rel="noreferrer noopener">Här är hästarna som bjuds ut på kvällens auktion på Travera.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7Igår kväll vann <strong>Late Night</strong> (e. Great Challenger) Aalborg Hoppechampionat för fyraåriga ston i Ålborg. Flemming Jensen satt satt i sulkyn bakom Stoderbytrean som tränas av Henrik Lönborg och det var närmast en solouppvisning från start till mål. Late Night anförde i ett par längders ledning och det var först i slutsvängen konkurrenterna ville vara med och göra upp om det. Då lättade Jensen på tömmarna och Late Night stack undan till lätt seger på 1.15,1a/2.140 meter. </p>



<p class="wp-block-paragraph">Ikväll är det hingstarnas tur i ”Derbyrevanschen” Aalborg Stora Pris med 100.000 danska kronor till vinnaren. Fast någon chans till revansch på danske Derbyvinanren blir det inte. Johan Untersteiner står nämligen över loppet med <strong>Lazy Dust</strong> (e. Brillantissime).</p>



<p class="wp-block-paragraph">De stora namnen i fältet är istället tvåan och trean från danska Derbyt, <strong>Lee Marvin</strong> (e. Nuncio) och <strong>Ludvig Cash</strong> (e. Power). Det svenska inslaget står Jörgen Sjunnesson för som gästkusk bakom Steen Juul-tränade <strong>Lanson</strong> (e. Googoo Gaagaa), som vann Derby consolation på Charlottenlund tillsammans i senaste starten.</p>



<p class="wp-block-paragraph"><strong>Startlista Aalborg Stora Pris</strong><br>2.140 meter autostart<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li><strong>Lemmy</strong> (e. Traders) – Patrick Larsen</li>



<li><strong>Labour Spring</strong> (e. Trophy Catch) – Knud Mönster</li>



<li><strong>Lookerbie Diamond</strong> (e. Who’s Who) – Flemming Jensen</li>



<li><strong>L.O.C.</strong> (e. Ens Snapshot) – Morten Juul</li>



<li><strong>Leo Wynn</strong> (e. Maharajah) – Jeppe Juel</li>



<li><strong>Lonesomerider</strong> (e. Power) – Jan Dahlgaard</li>



<li><strong>Licorice Cash</strong> (e. Cash And Go) – Morten Friis</li>



<li><strong>Look Like Gaagaa</strong> (e. Googoo Gaagaa) – Kristian Malmin</li>



<li><strong>Lanson</strong> (e. Googoo Gaagaa) – Jörgen Sjunnesson</li>



<li><strong>Lee Marvin</strong> (e. Nuncio) – Birger Jörgensen</li>



<li><strong>Ludvig Cash</strong> (e. Power) – Rene Kjaer</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Svensk utklassning igen?
Så överlägset är Sverige mot Norge. Matchningsplanen för Go On Boy. Alla svenskar i Frankrike. Umeåtränare i stor final. 55 hästar söker nya ägare.
Detta och mer bland lördagens nyheter.
Detta och mer bland lördagens nyheter.
