diff --git a/app/models/enable_banking_entry/processor.rb b/app/models/enable_banking_entry/processor.rb
index 77bfd3943..dda838319 100644
--- a/app/models/enable_banking_entry/processor.rb
+++ b/app/models/enable_banking_entry/processor.rb
@@ -6,6 +6,21 @@ class EnableBankingEntry::Processor
   # Small-merchant card terminal providers that prefix the payee with "KEYWORD *"
   PAYMENT_PROCESSOR_PREFIX = /\A(SUMUP|SQ|IZETTLE|ZETTLE|PAYPAL)\s*\*\s*/i
 
+  # Austrian/German retail POS terminals often include a "DANKT"/"DANKE" thank-you
+  # marker somewhere in the merchant line (e.g. "<CHAIN> DANKT ..." or
+  # "DANKE ... <CHAIN>"). It's never part of the retailer's actual name, so it's
+  # safe to remove -- but its position relative to the merchant name isn't fixed,
+  # so only the marker word itself is removed rather than truncating the line at
+  # it. Used as a last-resort fallback when no known merchant name matches (see
+  # matched_known_merchant_name) -- generalizes across retailers and phrasings
+  # without risking the real merchant name being cut off.
+  LOYALTY_MARKER_WORD = /\b(DANKT|DANKE)\b/i
+
+  # Guard against spurious matches from very short known merchant names (e.g. a
+  # 2-letter FamilyMerchant name matching inside unrelated text, like "IT" would
+  # inside "NAME IT" -- a real chain name observed in this issue's own data).
+  MIN_KNOWN_MERCHANT_MATCH_LENGTH = 3
+
   # enable_banking_transaction is the raw hash fetched from Enable Banking API
   # Transaction structure from Enable Banking:
   # {
@@ -224,7 +239,9 @@ class EnableBankingEntry::Processor
     def primary_remittance_information
       lines = remittance_information_lines
       descriptive = lines.find { |line| !technical_remittance_line?(line) } || lines.first
-      strip_payment_processor_prefix(descriptive)
+      return descriptive if descriptive.blank?
+
+      matched_known_merchant_name(descriptive) || strip_loyalty_marker(strip_payment_processor_prefix(descriptive))
     end
 
     def remittance_information_lines
@@ -243,8 +260,10 @@ class EnableBankingEntry::Processor
       # no separate technical-only element) would wrongly match on the prefix alone,
       # and a line like "Invoice paid 31.07. 10:27" would wrongly match on the date
       # suffix alone. Requiring both matches every real technical line observed in
-      # production while leaving both of those legitimate shapes untouched.
-      line.match?(/\A(POS|ATM)\s+\d+[.,]\d{2}\b.*\d{2}[.\/]\d{2}\.?\s+\d{2}:\d{2}\z/i)
+      # production while leaving both of those legitimate shapes untouched. Day/month
+      # accept 1-2 digits (not just 2) so an un-padded ASPSP date ("1.07." instead of
+      # "01.07.") is still recognized as technical.
+      line.match?(/\A(POS|ATM)\s+\d+[.,]\d{2}\b.*\d{1,2}[.\/]\d{1,2}\.?\s+\d{2}:\d{2}\z/i)
     end
 
     def strip_payment_processor_prefix(value)
@@ -252,12 +271,53 @@ class EnableBankingEntry::Processor
       value.sub(PAYMENT_PROCESSOR_PREFIX, "").strip.presence || value
     end
 
+    def strip_loyalty_marker(value)
+      return value if value.blank?
+      # Only touch the string when the marker is actually present -- squeeze/strip
+      # would otherwise also collapse intentional multi-space formatting (e.g. the
+      # raw technical POS line) on lines that never had a marker to remove.
+      return value unless value.match?(LOYALTY_MARKER_WORD)
+      value.sub(LOYALTY_MARKER_WORD, "").squeeze(" ").strip.presence || value
+    end
+
+    # Prefer a merchant name the family already knows over any text heuristic: it's
+    # already clean/trusted, and sidesteps guessing which parts of a POS line are
+    # noise (store numbers, city, thank-you markers, ...) vs. part of the name.
+    # Case-insensitive, whole-word match; the *stored* name (and its casing) wins,
+    # so e.g. "BILLA DANKT 0007114" resolves to "Billa", not "BILLA". Longest match
+    # wins when multiple known names match (prefer the more specific one).
+    def matched_known_merchant_name(line)
+      candidates = known_merchant_names.select { |name| name.length >= MIN_KNOWN_MERCHANT_MATCH_LENGTH }
+      # Lookaround instead of \b at both ends: \b only fires on a word/non-word
+      # transition, so it silently fails to match right after a name that itself
+      # ends in punctuation (e.g. "A+B (Café)" ends in ")" -- a non-word char next
+      # to another non-word char has no \b between them). Asserting "the boundary
+      # character, if any, isn't alphanumeric" works regardless of how the known
+      # name itself starts/ends.
+      matches = candidates.select do |name|
+        line.match?(/(?<![[:alnum:]_])#{Regexp.escape(name)}(?![[:alnum:]_])/i)
+      end
+      matches.max_by(&:length)
+    end
+
+    def known_merchant_names
+      @known_merchant_names ||= account&.family&.known_merchant_names || []
+    end
+
     def merchant_name_candidate
       counterparty = counterparty_name.to_s.strip
       return counterparty if counterparty.present? && !technical_card_counterparty?(counterparty)
-      # For technical CARD-* counterparties, reuse remittance as the best merchant candidate
+
       remittance = primary_remittance_information
-      return remittance.truncate(100, omission: "") if remittance.present? && technical_card_counterparty?(counterparty)
+      return nil if remittance.blank?
+
+      # Trust remittance-derived text as a merchant candidate when either the
+      # counterparty was a technical CARD-* placeholder (existing Wise case), or
+      # the text matched an ALREADY-KNOWN merchant for this family. Inventing a
+      # brand-new merchant from raw noisy POS text (blank counterparty, no CARD-*
+      # signal, no known-merchant match) stays out of scope, unchanged from #2935.
+      return remittance.truncate(100, omission: "") if technical_card_counterparty?(counterparty)
+      return remittance if known_merchant_names.include?(remittance)
 
       nil
     end
diff --git a/app/models/family.rb b/app/models/family.rb
index adec49617..2f5817a7d 100644
--- a/app/models/family.rb
+++ b/app/models/family.rb
@@ -267,6 +267,15 @@ class Family < ApplicationRecord
     Merchant.where(id: (assigned_ids + recently_unlinked_ids + family_merchant_ids).uniq)
   end
 
+  # Merchant names already associated with this family (via any provider, or a
+  # manually created FamilyMerchant) -- used to recognize a merchant embedded in
+  # noisy provider text (e.g. Enable Banking's remittance lines) without
+  # inventing a new one from scratch. Deliberately excludes recently-unlinked
+  # merchants (unlike available_merchants), since those were explicitly removed.
+  def known_merchant_names
+    (assigned_merchants.pluck(:name) + merchants.pluck(:name)).uniq
+  end
+
   def assigned_merchants_for(user)
     merchant_ids = Transaction.joins(:entry)
       .where(entries: { account_id: accounts.accessible_by(user).select(:id) })
diff --git a/test/models/enable_banking_entry/processor_test.rb b/test/models/enable_banking_entry/processor_test.rb
index ebbb292f7..1e5142be9 100644
--- a/test/models/enable_banking_entry/processor_test.rb
+++ b/test/models/enable_banking_entry/processor_test.rb
@@ -1,4 +1,5 @@
 require "test_helper"
+require "ostruct"
 
 class EnableBankingEntry::ProcessorTest < ActiveSupport::TestCase
   setup do
@@ -220,17 +221,118 @@ class EnableBankingEntry::ProcessorTest < ActiveSupport::TestCase
       credit_debit_indicator: "DBIT",
       remittance_information: [
         "POS          45,13 AT  D6   31.07. 10:27",
-        "BILLA DANKT 0007114 SIEGENDORF 7011"
+        "BILLA DANKT 0007114"
       ],
       status: "BOOK"
     }
 
     EnableBankingEntry::Processor.new(tx, enable_banking_account: @enable_banking_account).process
     entry = @account.entries.find_by!(external_id: "enable_banking_ref_pos_2935")
-    assert_equal "BILLA DANKT 0007114 SIEGENDORF 7011", entry.name
+    assert_equal "BILLA 0007114", entry.name
     assert_includes entry.notes, "POS          45,13 AT  D6   31.07. 10:27"
   end
 
+  test "uses the family's known merchant name instead of the raw remittance line when it matches, and assigns the merchant" do
+    @family.merchants.create!(name: "Billa")
+
+    tx = {
+      entry_reference: "ref_known_merchant",
+      transaction_id: nil,
+      booking_date: Date.current.to_s,
+      transaction_amount: { amount: "45.13", currency: "EUR" },
+      creditor: { name: "" },
+      bank_transaction_code: nil,
+      credit_debit_indicator: "DBIT",
+      remittance_information: [
+        "POS          45,13 AT  D6   31.07. 10:27",
+        "BILLA DANKT 0007114"
+      ],
+      status: "BOOK"
+    }
+
+    EnableBankingEntry::Processor.new(tx, enable_banking_account: @enable_banking_account).process
+    entry = @account.entries.find_by!(external_id: "enable_banking_ref_known_merchant")
+
+    assert_equal "Billa", entry.name
+    assert_equal "Billa", entry.transaction.merchant&.name
+  end
+
+  test "matches known merchants regardless of retailer chain" do
+    %w[Bipa Spar Hofer Lidl Penny].each do |chain_name|
+      @family.merchants.create!(name: chain_name)
+    end
+
+    [
+      [ "bipa", "BIPA DANKT 0001234", "Bipa" ],
+      [ "spar", "SPAR DANKT 0005678", "Spar" ],
+      [ "hofer", "HOFER DANKT 0009876", "Hofer" ],
+      [ "lidl", "LIDL DANKT 0004321", "Lidl" ],
+      [ "penny", "DANKE 0009999 PENNY", "Penny" ]
+    ].each do |ref_suffix, raw_line, expected_name|
+      tx = {
+        entry_reference: "ref_known_#{ref_suffix}",
+        transaction_id: nil,
+        booking_date: Date.current.to_s,
+        transaction_amount: { amount: "12.34", currency: "EUR" },
+        creditor: { name: "" },
+        bank_transaction_code: nil,
+        credit_debit_indicator: "DBIT",
+        remittance_information: [
+          "POS          12,34 AT  D6   01.01. 09:00",
+          raw_line
+        ],
+        status: "BOOK"
+      }
+
+      EnableBankingEntry::Processor.new(tx, enable_banking_account: @enable_banking_account).process
+      entry = @account.entries.find_by!(external_id: "enable_banking_ref_known_#{ref_suffix}")
+
+      assert_equal expected_name, entry.name, "expected #{raw_line.inspect} to resolve to #{expected_name.inspect}"
+    end
+  end
+
+  test "does not match a known merchant name shorter than the minimum match length" do
+    @family.merchants.create!(name: "IT")
+
+    name = build_name_with_family(
+      credit_debit_indicator: "DBIT",
+      creditor: { name: "" },
+      bank_transaction_code: nil,
+      remittance_information: [ "NAME IT 1234" ]
+    )
+
+    # No known merchant match attempted ("IT" is below MIN_KNOWN_MERCHANT_MATCH_LENGTH),
+    # and no DANKT/DANKE marker present, so the line passes through unchanged.
+    assert_equal "NAME IT 1234", name
+  end
+
+  test "prefers the longest matching known merchant name when multiple match" do
+    @family.merchants.create!(name: "Billa")
+    @family.merchants.create!(name: "Billa Corso")
+
+    name = build_name_with_family(
+      credit_debit_indicator: "DBIT",
+      creditor: { name: "" },
+      bank_transaction_code: nil,
+      remittance_information: [ "Billa Corso 0001234" ]
+    )
+
+    assert_equal "Billa Corso", name
+  end
+
+  test "escapes regex metacharacters in a known merchant name so matching never raises" do
+    @family.merchants.create!(name: "A+B (Café)")
+
+    name = build_name_with_family(
+      credit_debit_indicator: "DBIT",
+      creditor: { name: "" },
+      bank_transaction_code: nil,
+      remittance_information: [ "A+B (Café) 0001234" ]
+    )
+
+    assert_equal "A+B (Café)", name
+  end
+
   test "stores exchange_rate in extra when present" do
     tx = {
       entry_reference: "ref_fx",
@@ -305,13 +407,24 @@ class EnableBankingEntry::ProcessorTest < ActiveSupport::TestCase
   end
 
   def build_processor(data)
-    EnableBankingEntry::Processor.new(data, enable_banking_account: Object.new)
+    # A minimal stand-in that responds to current_account (real EnableBankingAccount
+    # always does) so `account`/`known_merchant_names` resolve safely to nil/[] instead
+    # of raising -- these unit-level tests aren't wired to a real family, so they always
+    # exercise the "no known merchant" fallback path.
+    EnableBankingEntry::Processor.new(data, enable_banking_account: OpenStruct.new(current_account: nil))
   end
 
   def build_name(data)
     build_processor(data).send(:name)
   end
 
+  # Unlike build_name/build_processor, wires up the real @enable_banking_account
+  # (and thus the real @family) so known-merchant matching has something to match
+  # against -- used by tests that create FamilyMerchant records via @family first.
+  def build_name_with_family(data)
+    EnableBankingEntry::Processor.new(data, enable_banking_account: @enable_banking_account).send(:name)
+  end
+
   test "skips technical card counterparty and falls back to remittance_information" do
     name = build_name(
       credit_debit_indicator: "CRDT",
@@ -463,11 +576,11 @@ class EnableBankingEntry::ProcessorTest < ActiveSupport::TestCase
       bank_transaction_code: nil,
       remittance_information: [
         "POS          45,13 AT  D6   31.07. 10:27",
-        "BILLA DANKT 0007114 SIEGENDORF 7011"
+        "BILLA DANKT 0007114"
       ]
     )
 
-    assert_equal "BILLA DANKT 0007114 SIEGENDORF 7011", name
+    assert_equal "BILLA 0007114", name
   end
 
   test "skips generic ATM terminal line and uses real merchant from remittance_information" do
@@ -490,12 +603,12 @@ class EnableBankingEntry::ProcessorTest < ActiveSupport::TestCase
       creditor: { name: "" },
       bank_transaction_code: nil,
       remittance_information: [
-        "POS 45,13 BILLA DANKT 0007114 SIEGENDORF 7011",
+        "POS 45,13 BILLA DANKT 0007114",
         "Reference 0394676"
       ]
     )
 
-    assert_equal "POS 45,13 BILLA DANKT 0007114 SIEGENDORF 7011", name
+    assert_equal "POS 45,13 BILLA 0007114", name
   end
 
   test "does not treat a legitimate line as technical just because it ends with a date+time stamp" do
@@ -526,6 +639,40 @@ class EnableBankingEntry::ProcessorTest < ActiveSupport::TestCase
     assert_equal "HERR DR. EISENSTADT 7000", name
   end
 
+  test "removes the DANKT/DANKE thank-you marker regardless of retailer chain or its position in the line" do
+    [
+      [ "BIPA DANKT 0001234", "BIPA 0001234" ],
+      [ "SPAR DANKT 0005678", "SPAR 0005678" ],
+      [ "HOFER DANKT 0009876", "HOFER 0009876" ],
+      [ "LIDL DANKT 0004321", "LIDL 0004321" ],
+      [ "PENNY DANKE 0002468", "PENNY 0002468" ],
+      [ "DANKE 0009999 PENNY", "0009999 PENNY" ]
+    ].each do |raw_line, expected_name|
+      name = build_name(
+        credit_debit_indicator: "DBIT",
+        creditor: { name: "" },
+        bank_transaction_code: nil,
+        remittance_information: [
+          "POS          12,34 AT  D6   01.01. 09:00",
+          raw_line
+        ]
+      )
+
+      assert_equal expected_name, name, "expected #{raw_line.inspect} to normalize to #{expected_name.inspect}"
+    end
+  end
+
+  test "does not alter a name that merely contains 'dank' as a substring" do
+    name = build_name(
+      credit_debit_indicator: "DBIT",
+      creditor: { name: "" },
+      bank_transaction_code: nil,
+      remittance_information: [ "STEFAN DANKL GMBH" ]
+    )
+
+    assert_equal "STEFAN DANKL GMBH", name
+  end
+
   test "falls back to the technical line when remittance_information has no descriptive line" do
     name = build_name(
       credit_debit_indicator: "DBIT",
diff --git a/test/models/family_test.rb b/test/models/family_test.rb
index f53be0b3a..ab99aedd6 100644
--- a/test/models/family_test.rb
+++ b/test/models/family_test.rb
@@ -173,6 +173,20 @@ class FamilyTest < ActiveSupport::TestCase
     assert_includes family.available_merchants, new_merchant
   end
 
+  test "known_merchant_names includes both assigned and family-owned merchant names, deduplicated" do
+    family = families(:dylan_family)
+
+    provider_merchant = ProviderMerchant.create!(name: "Known Provider Merchant", source: "enable_banking")
+    transactions(:one).update!(merchant: provider_merchant)
+    unassigned_family_merchant = family.merchants.create!(name: "Unassigned Family Merchant")
+
+    names = family.known_merchant_names
+
+    assert_includes names, "Known Provider Merchant"
+    assert_includes names, unassigned_family_merchant.name
+    assert_equal names.uniq, names
+  end
+
   test "enabled currencies always include the base currency" do
     family = families(:dylan_family)
     family.update!(currency: "SGD", enabled_currencies: [ "USD" ])