
<p class="has-drop-cap wp-block-paragraph">1Det bjuds topptrav på Bergsåker (första start 14.35) med både rikstotofinaler och dubbla E3-finaler över medeldistans. Roger Walmann toppar tränarligan i E3:s stoklass med sju vinnare sedan storloppet såg dagens ljus 1997. <strong>Tamla Celeber</strong> (e. Cantab Hall) och <strong>Giant Diablo</strong> (e. Supergill) vann dubbla finaler, medan <strong>Mellby Briolett</strong> (e. Going Kronos), <strong>Nursery Rhyme</strong> (e. Credit Winner) och<strong>S.G.Empress</strong> (e. Readly Express) vann en upplaga vardera.</p>



<p class="wp-block-paragraph">Tränarnestorn är med även i årets final, och har ett spännande kort i <strong>Mezzanine</strong> (e. Gimpanzee) som bland annat har en vass storebror att leva upp till. Mamma <strong>Deepdish</strong> (e. Muscle Hill), som köptes av Lennart Ågren i Lexington som ettåring för 320.000 dollar, har sin första avkomma i Kriterievinnaren <strong>Brambling</strong> (e. Bold Eagle), 1.09,7ak/5.760.091 kr.</p>



<p class="wp-block-paragraph">Mezzanine glänste i sitt uttagningslopp, där Rikard N Skoglund tidigt valde positionen utvändigt ledaren och därifrån gled Mezzanine undan på fint sätt och var långt ifrån bottnad.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/e3-redo-for-ny-stoseger/" target="_blank" rel="noreferrer noopener">Detta och mer om E3-finalen för ston i ”Det snackas om&#8230;” här!</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/06/260625e3hvlanga-617x333.jpg" alt="" class="wp-image-866897"/><figcaption class="wp-element-caption">Grosbois jagas av bland andra City Slicker, Neutron Star och Conrads Emil i långa E3-finalen på Bergsåker. Foto Gunilla König/Stalltz.se &#038; Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Treåringssäsongens storloppsvinnare bland hingstar och valacker på svensk mark är Björn Goop-tränade <strong>Grosbois</strong> (e. Maharajah), som lekte hem Breeders Course-finalen på Elitloppshelgen.</p>



<p class="wp-block-paragraph">– Grosbois har varit jättebra. Han gjorde en omdiskuterad sak i kvalet där han gjorde en u-sväng i sista sväng och störde bland annat Intro. Grosbois är en valpig herre, han gjorde så i försöket och även i sin debut på Åby och är lite sällskapssjuk. Han känns jättefin och senast tävlade han med järnskor. Nu blir det barfota som när han vann på Solvalla, säger Björn Goop i ”Björnkollen”. </p>



<p class="wp-block-paragraph">Björn Goop slog till som tränare och kusk i E3 redan 2004 med <strong>Conny Nobell</strong> (e. Pearsall Hanover) som tog hem den korta upplagan.</p>



<p class="wp-block-paragraph">Pensionerade Svante Båth är tränarkungen i E3 genom tiderna och enbart i hingst- och valackklassen tog han elva segrar! </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/e3-hv-2026/" target="_blank" rel="noreferrer noopener">Detta och mer om E3-finalen för hingstar och valacker i ”Det snackas om&#8230;” här!</a></p>



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



<p class="has-drop-cap wp-block-paragraph">3Nästan 16 miljoner kronor extra ligger i åttarättspotten, som spår landa på minst 35 miljoner kronor. Det blir både sport- och spelfest på Bergsåker på lördagen!<br>En av spikarna som experterna fastnat för är A Fair Days lillebror Brother Day (e. Maharajah) i klass II-finalen som avslutar streckspelet.<br>– Brother Day gjorde ett kanonlopp senast och hade nog vunnit om han inte rumplat till lite 75 kvar. Han är i en bra fas och såg stark ut i måndagsjobbet och läget blev mycket bra då han är kvick bakom bilen. Det ser intressant ut och det blir barfota bak och vanlig vagn, säger träanren Daniel Redén på sin hemsida reddis.se.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/spelstugan/v85-jackpot-b-27-juni/" target="_blank" rel="noreferrer noopener">––> Här är Sulkysports expertpanels bästa vinnare och spikar.</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/69ansspel/V85_2026-06-27_9_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-06-27_9_5">Här finns andelar till V85 hos Spelpoolen.</a> </p>



<p class="wp-block-paragraph">Det tävlas på ytterligare två svenska banor idag. Först ut är Åby (första start 11.10) .  men det blir även en kvällsomgång i Visby (första start 17.50). Roger Malmqvist har bara kört sju lopp hittills i år (tolv förra året) och vunnit ett av dessa. Ikväll blir det destor mer arbete i tävlingsvagnen när han är uppsatt på hela åtta hästar. En av styrningarna är egentränade, duktiga stoet Nikki Lane (e. Maharajah).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/06/260627.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/04/skarmavbild20260412kl.15.59.55-617x354.jpg" alt="" class="wp-image-837152"/><figcaption class="wp-element-caption">Xerava C.D. efter seger i Frankrike i april.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Förmiddagar och kvällar är det som gäller för travtävlingar i sommarhettans Frankrike och på Parisbanan Enghien (första start 18.40) blir det en hel del blågult. Fyra svenska tränare trotsar värmen och har hästar till start.</p>



<p class="wp-block-paragraph">Två dyker upp i tävlingskvällens största lopp, Prix du Roussillon (€68.000) över 2.150 meter autostart med 30.600 euro till vinnaren. Hans R trömberg-tränade <strong>Xerava C.D. </strong>(e. Uncle Lasse) drog innerspår bakom bilen tillsammans med Eric Raffin, medan Markus B Svedbergs <strong>Comes With Age</strong> (e. Zola Boko) startar i andra ledet tillsammans med Mathieu Mottier.</p>



<p class="wp-block-paragraph">Svedberg har även <strong>Michigan Bro</strong> (e. S.J.’s Caviar) till start i svensktäta Prix du Pont Louis-Philippe (€46.000) över 2.875 meter. Eric Raffin sitter i vagnen. <br>Här plockar numera Frankrikebaserade Elke Frinta ut <strong>Enjoy The Moment</strong> (e. Propulsion) och Fredrik Wallin <strong>Maserati Hall</strong> (e. Twister Bi). I loppet finns fler svenskfödda i <strong>Jacques Mearas</strong> (e. Ready Cash), <strong>Costello O.E. </strong>(e. Bold Eagle) och <strong>Pure Steel</strong> (e. Bird Parker).</p>



<p class="wp-block-paragraph">Elke Frinta visade fin form redan igår i Paris när hennes <strong>Perfect</strong> (e. Perfect Southwind) tog tredjeplatsen i Prix Isis (€46.000), värd 6.440 euro.</p>



<p class="wp-block-paragraph"><a href="https://www.letrot.com/courses/programme/2026-06-27/7502" target="_blank" rel="noreferrer noopener">Här är startlistorna till Enghiens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Hon är trea i allsvenska montéligan med nio vinster på 52 starter i sadeln. Dessurom har 25-åriga Saga Laursen vunnit två lopp i sulky och nått elva vinster totalt i år. Att det inte är något fel på formen råder inga tvivel om.</p>



<p class="wp-block-paragraph">I onsdags vann hon sulkylopp under sommartravet i Vaggeryd med <strong>Haymaker</strong> (e. HaYmaker). Torsdagen gav montévist på danskefödde <strong>Gejst</strong> (e. Traders) och igår var det dags igen med <strong>Crazy Frog M.C.</strong> (e. King Sir Kir) i ett montélopp på Mantorptravet.</p>



<p class="wp-block-paragraph">Men alla segerrader har ett slut och efter tre raka vinster fick Saga Laursen nöja sig med tredjeplatsen i ett sulkylopp på Axevala. Meryl Streep Boko var hästen som tog bronset när <strong>Keegan Pace</strong> (e. Raja Mirchi) och Melwin Johansson segrade.</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/massimohoist-617x333.jpg" alt="" class="wp-image-782887"/><figcaption class="wp-element-caption">Massimoi Hoist. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6Fjolårets finske Elitloppshäst <strong>Massimo Hoist</strong> (e. Muscle Hill) gör debut i ”ny” regi i Joensuus storlopp Joensuu Ajo (€21.000) idag. Riina Korhonen står nämligen numera som tränare till hästen, men det är en tillfällig läsning. Hästens ordinarie tränare Jukka Hakkarainen är avstängd i tre månader sedan en av hans hästar, <strong>Callela Callmeboss</strong> (e. Maharajan), testat positivt för doping. </p>



<p class="wp-block-paragraph">Massimo Hoist var även inbjuden till årets Elitlopp, men hoppade av sedan hästen visat svag form under våren. Han gjorde sin senaste start i Finlandia Ajo i början av maj, där han slutade femma.</p>



<p class="wp-block-paragraph">Bland motståndarna finns sex svenskfödda travare, däribland Combat Fighter (e. From Above). Både denne och Massimo Hoist ärinbjudna till Mikkeliloppet i juli.</p>



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



<ol class="wp-block-list">
<li><strong>Charmant de Zack</strong> (e. Vivid Wise As) – Ari Moilanen</li>



<li><strong>Global Beware</strong> (e. Ready Cash) – Tapio Perttunen</li>



<li><strong>Com Milton</strong> (e. Raja Mirchi) – Esa Holopainen</li>



<li><strong>Dozen of Oysters</strong> (e. Zola Boko) – Tuomas Pakkanen</li>



<li><strong>Massimo Hoist</strong> (e. Muscle Hill) – Hannu Torvinen</li>



<li><strong>Dundee As</strong> (e. Maharajah) – Jukka Torvinen</li>



<li><strong>Excusez Moi</strong> (e. Readly Express) – Tommi Kylliäinen</li>



<li><strong>Combat Fighter</strong> (e. From Above) – Santtu Raitala</li>



<li><strong>Need’em</strong> (e. Propulsion) – Tuukka Varis</li>



<li><strong>Kurri Jari Boko</strong> (e. Make It Happen) – Iikka Nurmonen</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7Snabbloppet på Forus på lördag har samlat en del spännande namn och Sverigebekantingar. Öystein Tjomslands varmblodiga unghäststjärna <strong>Felix Halbak</strong> (e. Orlando Vici) ägdes tidigare av först Tjomsland själv och sedan <br>Asap KB, Halmstad, men sedan i våras är det norska Stall King Felix som står för ägandet.</p>



<p class="wp-block-paragraph">Felix Halbak vann sista upplagan av Prinsesse Märtha Louises pokallopp på Biri som treåring och slutade trea i norska Kriteriet. Ifjol var han finalist i både Derbyt och Jarlsberg Grand Prix.<br>Efter vinteruppehåll gjorde hästen comeback för en  vecka sedan och vann direkt på 1.12,9a/2.040 meter på Forus. Nu väntar bland annat ett möte med en trio från Frode Hamres stall i svenskfödde <strong>Never Mind’em</strong> (e. Propulsion) – två segrar på tre starter efter flytten från Sverige – <strong>Nelson Daytona</strong> (e. Father Patrick) och <strong>Tix</strong> (e. El Diablo B.R.). Den sistnämnde slutade tvåa i norska Derbyt ifjol.</p>



<p class="wp-block-paragraph">Tjomsland tar också ut en femårig kallblodig unghäststjärna i svenskägda <strong>Hå Lerke</strong> (e. Nordsjö Odin). Bergsåker Open Trotters KB, Sundsvall, äger stoet som vann Derbystoet i Östersund förra sommaren, innan hon gjorde bort sig i norska Stoderbyt som storfavorit.<br>Nu har Hå Lerke seger i årsdebuten i maj bakom sig inför lördagens start mot äldre hästar.</p>



<p class="wp-block-paragraph"><a href="https://www.travsport.no/travbaner/forus-travbane/startlist/2026-06-27" target="_blank" rel="noreferrer noopener">Här är startlistorna till Forus tävlingar.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
E3-kung mot åttonde stosegern
Kungen i E3 för ston fyller på med ny vinst? Från järnskor till barfota runt om. Experternas jackpotspikar. Svensktätt i hettan i Paris. Sagas fina segersvit. Elitloppshäst i ny regi.
Detta och mer i lördagens ”Sju nyheter vid sju”.
Detta och mer i lördagens ”Sju nyheter vid sju”.
