
<p class="has-drop-cap">1 I mer än 40 år var <strong>Tommy Åström</strong> anställd på Gävletravets sekretariat och när Lennart Stenhorn gick i pension blev Åström sportchef på banan. Tommy var också en referent av hög klass. Många kommer säkert ihåg när han räknade ner från tio till noll över upploppet när <strong>Järvsöfaks</strong> slog världsrekord – <a href="https://www.youtube.com/watch?v=yl8iQ0-VMXU" target="_blank" rel="noreferrer noopener">se loppet och lyssna till Tommy här!</a> – med tiden 1.17,9a/1.640 meter i Gävle den 12 juli 2005. Det världsrekordet stod sig i över 20 år innan <strong>Brenne Borken</strong> (e. Bork Odin) vässade tiden till 1.17,7a/1.640 meter tillsammans med Öystein Tjomsland för en månad sedan.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2020/08/perssonjankolllopp-617x527.jpg" alt="" class="wp-image-105317" style="width:677px;height:auto"/><figcaption class="wp-element-caption">Jan-Olov Persson tittade långt efter skylten som visade sluttiden 1.17,9 för Järvsöfaks i Gävle 2005.           Idag körs referenten Tommy Åströms lopp i Gävle. Foto Stalltz.se</figcaption></figure>



<p>Tommy Åström gick ur tiden i början av 2024 och har haft ett eget lopp sedan han blev pensionär 2011.</p>



<p>När Gävletravet fyllde 80 år intervjuades Åström i en jubileumsbilaga och mindes tillbaka på några av höjdpunkterna på banan:<br class="">– När Greitind vann kallblodskampen (1964) törs jag påstå att det var största jublet jag varit med om på banan. Det var till och med så att det jublades rejält också i måldomarnämnden över den populära hemmasegern. Järvsöfaks världsrekord var något alldeles extra och samma sak gäller när Lutfi Kolgjini gästade med sina bästa hästar. Allra bästa loppet som körts tror jag ändå är när Grande Frances vann Gävle Stora Pris med Ulf Thoresen i ett oerhört kvalificerat gäng.</p>



<p>Kvällens upplaga av Tommy Åströms Minne har samlat ett koppel hästar som tävlat inom rikstoton den senaste tiden. Sju av tio hästar har testat i STL-sammanhang i sommar och de två minst rutinerade är också två femåringar med högst segeraptit. Tolv vinster på 19 starter har Daniel Redén-tränade <strong>Tamacti Jun</strong> (e. Readly Express), medan Hanna Rexhammars <strong>Money Matters</strong> (e. Expolosive Matter) vunnit tio av 19 starter.</p>



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



<p class="has-drop-cap">2 Finalen av Maharajahs stoserie avgörs på Gävletravet om fem veckor med sexsiffrig segercheck i en spårtrappa öppen för 15 ston. Sex försök ingår i serien och ikväll blir det två försök och chanser till poängsamlande<strong>. Chloe Broline</strong> (e. Explosive Matter) och <strong>Vibora</strong> (e. S.J.’s Caviar) sticker ut i den lägre klassen, medan <strong>Västerbo Cookie</strong> (e. Readly Express) och <strong>Xanthis Ibiza</strong> (e. International Moni) står bra till i det andra försöket.</p>



<p>Kvällen kompletteras med tävlingar i Skellefteå (start 17.45) och där inleds tävlingarna med ett treåringslopp i låg klass, men där det finns spännande inslag, främst i form av Stall SRF-produkten <strong>Babish</strong> (e. Perfect Spirit-Deepdish). Sandra Eriksson tränar och kör treåringen som jagar första segern i karriären i tredje starten och Kriterievinnaren <strong>Bramblings</strong> (e. Bold Eagle) lillasyster startar med 20 meters tillägg.</p>



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



<p class="has-drop-cap">3 Duktige Årjängskusken <strong>Niclas Benzon</strong> har ett starkt 2025 i sulkyn och har redan passerat fjolårssiffrorna med 20 segrar på 99 starter. Fler kan det bli på dagens lunchbana <strong>Årjäng</strong> (första start 12.20), där han framför allt jagar finalbiljett till <strong>Amatör-SM</strong> som avgörs på Åby den 27 september.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/07/13thelion-617x333.jpg" alt="" class="wp-image-588874"/><figcaption class="wp-element-caption">Niclas Benzon vid seger på Solvalla 2024. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>I dagens uttagningslopp kör han Lisa Skogh-tränade <strong>Fancy Free</strong> (e. Panne de Moteur), som för tre veckor sedan gjorde comeback efter sju månaders tävlingsuppehåll och vann direkt. </p>



<h2 class="wp-block-heading">Vinnare av kval till Amatör-SM:</h2>



<p><strong>Bana – Vinnare – Körsven/hemmabana</strong></p>



<p><strong>Örebro</strong> – Xander (e. Raja Mirchi) – Anna Sedström, Örebro<br><strong>Umåker</strong> – Hjalmar Xpress (e. From Above) – Frida Sandberg, Boden<br><strong>Hagmyren</strong> – Com Isidor (e. Villiam) – Håkan Persson, Hagmyren<br><strong>Jägersro</strong> – Silver Kornell (e. S.J.’s Caviar) – Robert Andersson, Jägersro<br><strong>Dannero</strong> – Quelebre (e. Love You) – Malin Viklund, Dannero<br><strong>Halmstad</strong> – Check Lane (e. S.J.’s Caviar) – Glenn Carlsson, Halmstad<br><strong>Romme</strong> – Kozmo Simoni (e. Django Riff) – Patrik Fernlund, Romme<br><strong>Östersund</strong> – Zirkon Klipp (e. Coin Perdu) – Lars Nylander, Bergsåker</p>



<p><strong>Här körs övriga försök:</strong> Årjäng (5 september), Mantorp (8 september), Solvalla (10 september), Åby (11 september).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/09/250905.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<p class="has-drop-cap">4 Det blev inte Wise Guy den här gången, men Per Nordströms E3-vinnare gjorde ett fullgott dagsverke som tvåa i Count’s Pride-pokalen på Åby igår. Åt ledande <strong>Cabello</strong> (e. Muscle Hill-Senorita Rita) och Magnus Teien Gundersen fanns inget att göra sedan treåringen skickats till ledningen i en 1.08-öppning första halvvarvet.</p>



<p>Cabello kunde säkert glida undan till seger på 1.14,1a/2.140 meter och Wise Guy avslutade fint som tvåa efter en resa i vinnarhålet.</p>



<p>– Jag hade bestämt mig för att köra till från start och det blev tufft första 500 meterna. Sedan fick jag värsta konkurrenten Wise Guy i rygg och då min häst är mer stark än snabb ökade jag farten tidigt i slutsvängen. Det här kan verkligen bli en jättebra häst och han är anmäld till både Kungapokalen och Sprintermästaren, sade Magnus Teien Gundersen om den USA-födde treåringen.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/gundersenedited-617x386.jpg" alt="" class="wp-image-763875" style="width:570px;height:auto"/><figcaption class="wp-element-caption">Magnus Teien Gundersen vann Count&#8217;s Pride Pokalen med Cabello. Foto: ATG-live</figcaption></figure>



<p>I Quick Pay-Pokalen för ston svarade Maria Törnqvists <strong>Slipstream Zon</strong> (e. Googoo Gaagaa-Trinidad As) för en mycket lovande insats från tät. Carl Johan Jepson var offensiv från start, men det dröjde nästan 500 meter innan han placerade Slipstream Zon i ledningen, men väl där var Googoo Gaagaa-dottern ohotad när hon dansade till vinst på 1.13,8a/2.140 meter. </p>



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



<p class="has-drop-cap">5 <strong>Hanna Lähdekorpi</strong> och <strong>Henriette Larsen</strong> var på förhand de klart mest meriterade kuskarna när Åbys uttagning till Dam-SM avgjordes igår kväll och det var just de två som knep finalbiljetterna till Åby den 27 september. Hanna Lähdekorpi körde Conrad Lugauers <strong>Franky Bahia</strong> (e. Maharajah) till vinst på 1.12,3a/2.140 meter medan Henriette Larsen styrde in Johan Untersteiners<strong> Quattro Håleryd</strong> (e. Maharajah) till silvret.</p>



<p>Det kördes även uttagningslopp till Dam-SM i Bollnäs och där gick <strong>Nathalie Blom </strong>segrande ur striden med Jennifer Perssons<strong> Vichel J.C.</strong> (e. Orlando Vici) efter ett rivigt lopp där många ville vara med och hugga om finalplatserna. Bakom vinnaren tog <strong>Felicia Jansson</strong> den andra biljetten till Åby bakom <strong>Evander Am</strong> (e. Jaded).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/04/gulifrodonbm230409adamstromstalltz-scaled-e1757015748928-617x356.jpg" alt="" class="wp-image-428342"/><figcaption class="wp-element-caption">Nathalie Blom vid tidigare seger på Solvalla. Foto: Adam Ström/stalltz.se</figcaption></figure>



<h2 class="wp-block-heading">Vinnare av Dam-SM uttagningslopp</h2>



<ul class="wp-block-list">
<li>18 augusti – Eskilstuna – <strong>Quinan Tooma </strong>(e. Donato Hanover) Ida Riesterer</li>



<li>24 augusti – Dannero – <strong>Gibson Brick</strong> (e. Make It Happen) Jessika Sidbäck</li>



<li>1 september – Färjestad – <strong>Tour de Valley</strong> (e. Classic Photo) Linda Sedström</li>



<li>4 september – Bollnäs – <strong>Vichel J.C.</strong> (e. Orlando Vici) Nathalie Blom</li>



<li>4 september – Åby – <strong>Franky Bahia</strong> (e. Maharajah) Hanna Lähdekorpi</li>



<li>10 september – Umåker – Boden, Skellefteå, Umåker</li>
</ul>



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



<p class="has-drop-cap">6 Det tävlas om stora prissummor i USA i kväll och som vanligt är det gott om svensktränade hästar med i fälten. </p>



<p>I Pennsylvania Sire Stakes-finalen för tvååriga ston ($300.000) på Harrah’s Philadelphia jagar Steven Cook-tränade <strong>Ginger Tree Lex</strong> (e. Bar Hopping-Perfect Chance) sjunde raka segern och motstånd kommer från både Åke Svanstedts och Marcus Melanders håll.</p>



<p>I PASS-finalen ($300.000) för tvååriga hingstar och valacker kan Captain Corey-sonen <strong>Mr Big Spender</strong> (e. Captain Corey-Reilly K) visa sig bli en tuff nöt att knäcka.</p>



<h2 class="wp-block-heading">Startlista PASS-final Ston</h2>



<p><em>Häst (hingst) – Tränare</em></p>



<ol class="wp-block-list">
<li>Cash Out Express (e. International Moni) – George Ducharme</li>



<li>Islandgirl Hanover (e. Captain Corey) – Trond Smedshammer</li>



<li>Next Big Think (e. Greenshoe) – Marcus Melander</li>



<li>Maya Patel Hanover (e. Captain Corey) – Åke Svanstedt</li>



<li>Ginger Tree Lex (e. Bar Hopping) – Steven Cook</li>



<li>Atlantic Summer (e. Captain Corey) – Ron Burke</li>



<li>Wendalyn Hanover (e. Greenshoe) – Vernon Beachy</li>



<li>Abbess (e. Father Patrick) – Chase Vandervort</li>
</ol>



<h2 class="wp-block-heading">PASS-final hingstar och valacker</h2>



<p><em>Häst (hingst) – Tränare</em></p>



<ol class="wp-block-list">
<li>Oversear (e. International Moni) – Charlie Norris</li>



<li>Dublin Hanover (e. Captain Corey) – Åke Svanstedt</li>



<li>Tymal Kryptonite (e. Greenshoe) – Steve Schoeffel</li>



<li>R Tommy Collins (e. Greenshoe) – Tom Svrcek</li>



<li>Highball Hanover (e. Bar Hopping) – Noel Daley</li>



<li>Mr Big Spender (e. Captain Corey) – Norm Parker</li>



<li>Minoan (e. Bar Hopping) – Noel Daley</li>



<li>Mr Penner (e. Captain Corey) – Åke Svanstedt</li>
</ol>



<p>På Meadowlands hålls finaler i New Jersey Classic ($250.000) senare på kvällen och det handlar om finaler för tvååringar, ston och hingstar och valacker, samt för treåringar i samma kategorier.</p>



<h2 class="wp-block-heading">New Jersey Classic ($250.000), tvååriga ston</h2>



<p><em>Häst (hingst) – Tränare</em></p>



<ol class="wp-block-list">
<li>Days Away (e. Muscle Hill) – Per Engblom</li>



<li>Lipstick (e. Tactical Landing) – Anette Lorentzon</li>



<li>Emmas Mystery Ccl (e. Muscle Hill) – Noel Daley</li>



<li>Sugar Packet (e. Six Pack) – Blake Macintosh</li>



<li>Kickan (e. Walner) – Nifty Norman</li>



<li>Southwind Chaska (e. Tactical Landing) – Jim Oscarsson</li>



<li>Nightcap Mearas S (e. Walner) – Lucas Wallin</li>



<li>Abbey Blue Chip (e. Tactical Landing) – Ron Coyne Jr</li>



<li>Sparks (e. Walner) – Åke Svanstedt</li>



<li>Patrona (e. Walner) – Nancy Takter</li>
</ol>



<h2 class="wp-block-heading">New Jersey Classic ($250.000), tvååriga hingstar och valacker</h2>



<p><em>Häst (hingst) – Tränare</em></p>



<ol class="wp-block-list">
<li>Captain Jordan (e. Captain Corey) – Scott Di Domenico</li>



<li>Rambo Hanover (e. Muscle Hill) – Åke Svanstedt</li>



<li>Practical Man (e. Tactical Landing) – Jim Campbell</li>



<li>Apex (e. Walner) – Marcus Melander</li>



<li>David Seaman S (e. Six Pack) – Åke Svanstedt</li>



<li>Diabolic Hill (e. Muscle Hill) – Anne Stoebe</li>



<li>Jim Beam (e. Captain Corey) – Scott Di Domenico</li>



<li>Southwind Alamo (e. Tactical Landing) – Ron Coyne Jr</li>



<li>Maga Hill (e. Muscle Hill) – Ron Burke</li>



<li>Nordic Dancer S (e. Six Pack) – Åke Svanstedt</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/apex2982025lisa-617x346.jpeg" alt="" class="wp-image-761540"/><figcaption class="wp-element-caption">Apex och Dexter Dunn vid seger på MeadowlandsFoto: Lisa Photo</figcaption></figure>



<h2 class="wp-block-heading">New Jersey Classic ($250.000), treåriga ston</h2>



<p><em>Häst (hingst) – Tränare</em></p>



<ol class="wp-block-list">
<li>Walspea (e. Walner) – Trond Smedshammer</li>



<li>Conversano (e. Muscle Hill) – Juan Cano</li>



<li>Xalapa (e. Muscle Hill) – Nancy Takter</li>



<li>C Me B Me (e. Muscle Hill) – Lucas Wallin</li>



<li>Yo Tillie (e. Tactical Landing) – Andrew Harris</li>



<li>Murial (e. Walner) – Domenico Cecere</li>



<li>Champagne Problems (e. Tactical Landing) – Nancy Takter</li>



<li>Miss Belmar (e. Muscle Hill) – Noel Daley</li>



<li>Glutes Hanover (e. Six Pack) – Tony Alagna</li>



<li>Corner Stone (e. Six Pack) – Paul Kelley</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/08/conversano1oaks-617x334.jpg" alt="" class="wp-image-750803"/><figcaption class="wp-element-caption">Conversano och James MacDonald spurtar till vinst i Hambletonian Oaks. Foto: Gerard Forni</figcaption></figure>



<h2 class="wp-block-heading">New Jersey Classic ($250.000), treåriga hingstar och valacker</h2>



<p><em>Häst (hingst) – Tränare</em></p>



<ol class="wp-block-list">
<li>Go Ahead Makemyday (e. Walner) – Blake Macintosh</li>



<li>The Rouge Prince (e. Walner) – Lucas Wallin</li>



<li>Warrior (e. Walner) – Åke Svanstedt</li>



<li>Mountcastle (e. Muscle Hill) – Marcus Melander</li>



<li>Yannick G Kemp (e. Walner) – Nifty Norman</li>



<li>Onajetplane (e. Walner) – Noel Daley</li>



<li>Camera Man (e. Six Pack) – Bruce Saunders</li>



<li>Go Boom (e. Muscle Hill) – Marcus Melander</li>



<li>Moni Man (e. Walner) – Paul Kelley</li>



<li>Don’t Ask For More (e. Walner) – Åke Svanstedt</li>
</ol>



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



<p class="has-drop-cap">7 Attraversiamo-dottern <strong>Attras Cash</strong> (u. Cash Mearas e. Ready Cash) svarade för en mycket stark tävlingsdebut i Bollnäs under torsdagen. Det tvååriga stoet ingår i Attraversiamos (e. Kiss Francais-Rhythm Kronos) första kull, födda 2023 och Attras Cash blev också hingstens första svenskfödda vinnare på svensk mark. 14 hästar ingår i kullen för hästar födda 2023. Daniel Wäjersten tränar och Mats E Djuse satt i segersulkyn vid debutsegern på 1.17,6/1.640 meter.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/attrascash-617x316.jpg" alt="" class="wp-image-763879" style="width:610px;height:auto"/><figcaption class="wp-element-caption">Attras Cash sprintar till seger för Mats E Djuse. Foto: Skärmbild ATG-live.</figcaption></figure>

Fokustema
Sju nyheter vid sju
Läs senare
Åströms lopp i Gävle
Tommy Åström hedras i Gävle. Topplopp på andra sidan Atlanten.
Hanna och Henriette vidare till SM. Wise Guy nådde inte fram.
Där har ni några av ämnena i Sju nyheter vid sju.
